Home | History | Annotate | Download | only in cts
      1 /*
      2  * Copyright (C) 2009 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 package android.media.cts;
     17 
     18 import android.app.ActivityManager;
     19 import android.content.res.AssetFileDescriptor;
     20 import android.media.cts.R;
     21 
     22 
     23 import android.app.Activity;
     24 import android.app.Instrumentation;
     25 import android.content.Context;
     26 import android.content.pm.PackageManager;
     27 import android.database.Cursor;
     28 import android.media.AudioManager;
     29 import android.media.Ringtone;
     30 import android.media.RingtoneManager;
     31 import android.net.Uri;
     32 import android.platform.test.annotations.AppModeFull;
     33 import android.provider.Settings;
     34 import android.test.ActivityInstrumentationTestCase2;
     35 import android.util.Log;
     36 
     37 import java.io.FileNotFoundException;
     38 import java.io.IOException;
     39 
     40 @AppModeFull(reason = "TODO: evaluate and port to instant")
     41 public class RingtoneManagerTest
     42         extends ActivityInstrumentationTestCase2<RingtonePickerActivity> {
     43 
     44     private static final String PKG = "android.media.cts";
     45     private static final String TAG = "RingtoneManagerTest";
     46 
     47     private RingtonePickerActivity mActivity;
     48     private Instrumentation mInstrumentation;
     49     private Context mContext;
     50     private RingtoneManager mRingtoneManager;
     51     private AudioManager mAudioManager;
     52     private int mOriginalVolume;
     53     private Uri mDefaultUri;
     54 
     55     public RingtoneManagerTest() {
     56         super(PKG, RingtonePickerActivity.class);
     57     }
     58 
     59     @Override
     60     protected void setUp() throws Exception {
     61         super.setUp();
     62         mActivity = getActivity();
     63         mInstrumentation = getInstrumentation();
     64         mContext = mInstrumentation.getContext();
     65         Utils.enableAppOps(mContext.getPackageName(), "android:write_settings", mInstrumentation);
     66         mRingtoneManager = new RingtoneManager(mActivity);
     67         mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
     68         // backup ringer settings
     69         mOriginalVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_RING);
     70         mDefaultUri = RingtoneManager.getActualDefaultRingtoneUri(mContext,
     71                 RingtoneManager.TYPE_RINGTONE);
     72 
     73         if (mAudioManager.getRingerMode() == AudioManager.RINGER_MODE_SILENT
     74                 && !ActivityManager.isLowRamDeviceStatic()) {
     75             try {
     76                 Utils.toggleNotificationPolicyAccess(
     77                         mContext.getPackageName(), getInstrumentation(), true);
     78                 mAudioManager.adjustStreamVolume(AudioManager.STREAM_RING,
     79                         AudioManager.ADJUST_RAISE,
     80                         AudioManager.FLAG_ALLOW_RINGER_MODES);
     81             } finally {
     82                 Utils.toggleNotificationPolicyAccess(
     83                         mContext.getPackageName(), getInstrumentation(), false);
     84             }
     85         }
     86     }
     87 
     88     @Override
     89     protected void tearDown() throws Exception {
     90         if (!ActivityManager.isLowRamDeviceStatic()) {
     91             try {
     92                 Utils.toggleNotificationPolicyAccess(
     93                         mContext.getPackageName(), getInstrumentation(), true);
     94                 // restore original ringer settings
     95                 if (mAudioManager != null) {
     96                     mAudioManager.setStreamVolume(AudioManager.STREAM_RING, mOriginalVolume,
     97                             AudioManager.FLAG_ALLOW_RINGER_MODES);
     98                 }
     99             } finally {
    100                 Utils.toggleNotificationPolicyAccess(
    101                         mContext.getPackageName(), getInstrumentation(), false);
    102             }
    103         }
    104         RingtoneManager.setActualDefaultRingtoneUri(mContext, RingtoneManager.TYPE_RINGTONE,
    105                 mDefaultUri);
    106         Utils.disableAppOps(mContext.getPackageName(), "android:write_settings", mInstrumentation);
    107         super.tearDown();
    108     }
    109 
    110     private boolean isSupportedDevice() {
    111         final PackageManager pm = mContext.getPackageManager();
    112         return pm.hasSystemFeature(PackageManager.FEATURE_AUDIO_OUTPUT)
    113                 && !pm.hasSystemFeature(PackageManager.FEATURE_LEANBACK_ONLY);
    114     }
    115 
    116     public void testConstructors() {
    117         if (!isSupportedDevice()) return;
    118 
    119         new RingtoneManager(mActivity);
    120         new RingtoneManager(mContext);
    121     }
    122 
    123     public void testAccessMethods() {
    124         if (!isSupportedDevice()) return;
    125 
    126         Cursor c = mRingtoneManager.getCursor();
    127         assertTrue("Must have at least one ring tone available", c.getCount() > 0);
    128 
    129         assertNotNull(mRingtoneManager.getRingtone(0));
    130         assertNotNull(RingtoneManager.getRingtone(mContext, Settings.System.DEFAULT_RINGTONE_URI));
    131         int expectedPosition = 0;
    132         Uri uri = mRingtoneManager.getRingtoneUri(expectedPosition);
    133         assertEquals(expectedPosition, mRingtoneManager.getRingtonePosition(uri));
    134         assertNotNull(RingtoneManager.getValidRingtoneUri(mContext));
    135 
    136         RingtoneManager.setActualDefaultRingtoneUri(mContext, RingtoneManager.TYPE_RINGTONE, uri);
    137         assertEquals(uri, RingtoneManager.getActualDefaultRingtoneUri(mContext,
    138                 RingtoneManager.TYPE_RINGTONE));
    139 
    140         try (AssetFileDescriptor afd = RingtoneManager.openDefaultRingtoneUri(
    141                 mActivity, RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE))) {
    142             assertNotNull(afd);
    143         } catch (IOException e) {
    144             fail(e.getMessage());
    145         }
    146 
    147         Uri bogus = Uri.parse("content://a_bogus_uri");
    148         RingtoneManager.setActualDefaultRingtoneUri(mContext, RingtoneManager.TYPE_RINGTONE, bogus);
    149         assertEquals(bogus, RingtoneManager.getActualDefaultRingtoneUri(mContext,
    150                 RingtoneManager.TYPE_RINGTONE));
    151 
    152         try (AssetFileDescriptor ignored = RingtoneManager.openDefaultRingtoneUri(
    153                 mActivity, RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE))) {
    154             fail("FileNotFoundException should be thrown for a bogus Uri.");
    155         } catch (FileNotFoundException e) {
    156             // Expected.
    157         } catch (IOException e) {
    158             fail(e.getMessage());
    159         }
    160 
    161         assertEquals(Settings.System.DEFAULT_RINGTONE_URI,
    162                 RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE));
    163         assertEquals(Settings.System.DEFAULT_NOTIFICATION_URI,
    164                 RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION));
    165         assertEquals(RingtoneManager.TYPE_RINGTONE,
    166                 RingtoneManager.getDefaultType(Settings.System.DEFAULT_RINGTONE_URI));
    167         assertEquals(RingtoneManager.TYPE_NOTIFICATION,
    168                 RingtoneManager.getDefaultType(Settings.System.DEFAULT_NOTIFICATION_URI));
    169         assertTrue(RingtoneManager.isDefault(Settings.System.DEFAULT_RINGTONE_URI));
    170     }
    171 
    172     public void testSetType() {
    173         if (!isSupportedDevice()) return;
    174 
    175         mRingtoneManager.setType(RingtoneManager.TYPE_ALARM);
    176         assertEquals(AudioManager.STREAM_ALARM, mRingtoneManager.inferStreamType());
    177         Cursor c = mRingtoneManager.getCursor();
    178         assertTrue("Must have at least one alarm tone available", c.getCount() > 0);
    179         Ringtone r = mRingtoneManager.getRingtone(0);
    180         assertEquals(RingtoneManager.TYPE_ALARM, r.getStreamType());
    181     }
    182 
    183     public void testStopPreviousRingtone() {
    184         if (!isSupportedDevice()) return;
    185 
    186         Cursor c = mRingtoneManager.getCursor();
    187         assertTrue("Must have at least one ring tone available", c.getCount() > 0);
    188 
    189         mRingtoneManager.setStopPreviousRingtone(true);
    190         assertTrue(mRingtoneManager.getStopPreviousRingtone());
    191         Uri uri = Uri.parse("android.resource://" + PKG + "/" + R.raw.john_cage);
    192         Ringtone ringtone = RingtoneManager.getRingtone(mContext, uri);
    193         ringtone.play();
    194         assertTrue(ringtone.isPlaying());
    195         ringtone.stop();
    196         assertFalse(ringtone.isPlaying());
    197         Ringtone newRingtone = mRingtoneManager.getRingtone(0);
    198         assertFalse(ringtone.isPlaying());
    199         newRingtone.play();
    200         assertTrue(newRingtone.isPlaying());
    201         mRingtoneManager.stopPreviousRingtone();
    202         assertFalse(newRingtone.isPlaying());
    203     }
    204 
    205     public void testQuery() {
    206         if (!isSupportedDevice()) return;
    207 
    208         final Cursor c = mRingtoneManager.getCursor();
    209         assertTrue(c.moveToFirst());
    210         assertTrue(c.getInt(RingtoneManager.ID_COLUMN_INDEX) >= 0);
    211         assertTrue(c.getString(RingtoneManager.TITLE_COLUMN_INDEX) != null);
    212         assertTrue(c.getString(RingtoneManager.URI_COLUMN_INDEX),
    213                 c.getString(RingtoneManager.URI_COLUMN_INDEX).startsWith("content://"));
    214     }
    215 }
    216