Home | History | Annotate | Download | only in cts
      1 /*
      2  * Copyright (C) 2008 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.media.cts;
     18 
     19 import android.app.ActivityManager;
     20 import android.app.UiAutomation;
     21 import android.content.Context;
     22 import android.content.pm.PackageManager;
     23 import android.media.AudioAttributes;
     24 import android.media.AudioManager;
     25 import android.media.Ringtone;
     26 import android.media.RingtoneManager;
     27 import android.net.Uri;
     28 import android.platform.test.annotations.AppModeFull;
     29 import android.provider.Settings;
     30 import android.test.InstrumentationTestCase;
     31 import android.util.Log;
     32 
     33 @AppModeFull(reason = "TODO: evaluate and port to instant")
     34 public class RingtoneTest extends InstrumentationTestCase {
     35     private static final String TAG = "RingtoneTest";
     36 
     37     private Context mContext;
     38     private Ringtone mRingtone;
     39     private AudioManager mAudioManager;
     40     private int mOriginalVolume;
     41     private int mOriginalRingerMode;
     42     private int mOriginalStreamType;
     43     private Uri mDefaultRingUri;
     44 
     45     @Override
     46     protected void setUp() throws Exception {
     47         super.setUp();
     48         enableAppOps();
     49         mContext = getInstrumentation().getContext();
     50         mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
     51         mRingtone = RingtoneManager.getRingtone(mContext, Settings.System.DEFAULT_RINGTONE_URI);
     52         // backup ringer settings
     53         mOriginalRingerMode = mAudioManager.getRingerMode();
     54         mOriginalVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_RING);
     55         mOriginalStreamType = mRingtone.getStreamType();
     56 
     57         int maxVolume = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_RING);
     58 
     59         if (mAudioManager.getRingerMode() == AudioManager.RINGER_MODE_VIBRATE) {
     60             mAudioManager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
     61             mAudioManager.setStreamVolume(AudioManager.STREAM_RING, maxVolume / 2,
     62                     AudioManager.FLAG_ALLOW_RINGER_MODES);
     63         } else if (mAudioManager.getRingerMode() == AudioManager.RINGER_MODE_NORMAL) {
     64             mAudioManager.setStreamVolume(AudioManager.STREAM_RING, maxVolume / 2,
     65                     AudioManager.FLAG_ALLOW_RINGER_MODES);
     66         } else if (!ActivityManager.isLowRamDeviceStatic()) {
     67             try {
     68                 Utils.toggleNotificationPolicyAccess(
     69                         mContext.getPackageName(), getInstrumentation(), true);
     70                 // set ringer to a reasonable volume
     71                 mAudioManager.setStreamVolume(AudioManager.STREAM_RING, maxVolume / 2,
     72                         AudioManager.FLAG_ALLOW_RINGER_MODES);
     73                 // make sure that we are not in silent mode
     74                 mAudioManager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
     75             } finally {
     76                 Utils.toggleNotificationPolicyAccess(
     77                         mContext.getPackageName(), getInstrumentation(), false);
     78             }
     79         }
     80 
     81         mDefaultRingUri = RingtoneManager.getActualDefaultRingtoneUri(mContext,
     82                 RingtoneManager.TYPE_RINGTONE);
     83     }
     84 
     85     private void enableAppOps() {
     86         StringBuilder cmd = new StringBuilder();
     87         cmd.append("appops set ");
     88         cmd.append(getInstrumentation().getContext().getPackageName());
     89         cmd.append(" android:write_settings allow");
     90         getInstrumentation().getUiAutomation().executeShellCommand(cmd.toString());
     91         try {
     92             Thread.sleep(2200);
     93         } catch (InterruptedException e) {
     94         }
     95     }
     96 
     97     @Override
     98     protected void tearDown() throws Exception {
     99         // restore original settings
    100         if (mRingtone != null) {
    101             if (mRingtone.isPlaying()) mRingtone.stop();
    102             mRingtone.setStreamType(mOriginalStreamType);
    103         }
    104         if (mAudioManager != null && !ActivityManager.isLowRamDeviceStatic()) {
    105             try {
    106                 Utils.toggleNotificationPolicyAccess(
    107                         mContext.getPackageName(), getInstrumentation(), true);
    108                 mAudioManager.setRingerMode(mOriginalRingerMode);
    109                 mAudioManager.setStreamVolume(AudioManager.STREAM_RING, mOriginalVolume,
    110                         AudioManager.FLAG_ALLOW_RINGER_MODES);
    111             } finally {
    112                 Utils.toggleNotificationPolicyAccess(
    113                         mContext.getPackageName(), getInstrumentation(), false);
    114             }
    115         }
    116         RingtoneManager.setActualDefaultRingtoneUri(mContext, RingtoneManager.TYPE_RINGTONE,
    117                 mDefaultRingUri);
    118         super.tearDown();
    119     }
    120 
    121     private boolean hasAudioOutput() {
    122         return getInstrumentation().getContext().getPackageManager()
    123                 .hasSystemFeature(PackageManager.FEATURE_AUDIO_OUTPUT);
    124     }
    125 
    126     private boolean isTV() {
    127         return getInstrumentation().getContext().getPackageManager()
    128                 .hasSystemFeature(PackageManager.FEATURE_LEANBACK_ONLY);
    129     }
    130 
    131     public void testRingtone() {
    132         if (isTV()) {
    133             return;
    134         }
    135         if (!hasAudioOutput()) {
    136             Log.i(TAG, "Skipping testRingtone(): device doesn't have audio output.");
    137             return;
    138         }
    139 
    140         assertNotNull(mRingtone.getTitle(mContext));
    141         assertTrue(mOriginalStreamType >= 0);
    142 
    143         mRingtone.setStreamType(AudioManager.STREAM_MUSIC);
    144         assertEquals(AudioManager.STREAM_MUSIC, mRingtone.getStreamType());
    145         mRingtone.setStreamType(AudioManager.STREAM_ALARM);
    146         assertEquals(AudioManager.STREAM_ALARM, mRingtone.getStreamType());
    147         // make sure we play on STREAM_RING because we the volume on this stream is not 0
    148         mRingtone.setStreamType(AudioManager.STREAM_RING);
    149         assertEquals(AudioManager.STREAM_RING, mRingtone.getStreamType());
    150 
    151         // test both the "None" ringtone and an actual ringtone
    152         RingtoneManager.setActualDefaultRingtoneUri(mContext, RingtoneManager.TYPE_RINGTONE, null);
    153         mRingtone = RingtoneManager.getRingtone(mContext, Settings.System.DEFAULT_RINGTONE_URI);
    154         assertTrue(mRingtone.getStreamType() == AudioManager.STREAM_RING);
    155         mRingtone.play();
    156         assertFalse(mRingtone.isPlaying());
    157 
    158         Uri uri = RingtoneManager.getValidRingtoneUri(mContext);
    159         assertNotNull("ringtone was unexpectedly null", uri);
    160         RingtoneManager.setActualDefaultRingtoneUri(mContext, RingtoneManager.TYPE_RINGTONE, uri);
    161         mRingtone = RingtoneManager.getRingtone(mContext, Settings.System.DEFAULT_RINGTONE_URI);
    162         assertTrue(mRingtone.getStreamType() == AudioManager.STREAM_RING);
    163         mRingtone.play();
    164         assertTrue("couldn't play ringtone " + uri, mRingtone.isPlaying());
    165         mRingtone.stop();
    166         assertFalse(mRingtone.isPlaying());
    167     }
    168 
    169     public void testLoopingVolume() {
    170         if (isTV()) {
    171             return;
    172         }
    173         if (!hasAudioOutput()) {
    174             Log.i(TAG, "Skipping testRingtone(): device doesn't have audio output.");
    175             return;
    176         }
    177 
    178         Uri uri = RingtoneManager.getValidRingtoneUri(mContext);
    179         assertNotNull("ringtone was unexpectedly null", uri);
    180         RingtoneManager.setActualDefaultRingtoneUri(mContext, RingtoneManager.TYPE_RINGTONE, uri);
    181         assertNotNull(mRingtone.getTitle(mContext));
    182         final AudioAttributes ringtoneAa = new AudioAttributes.Builder()
    183                 .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE).
    184                 build();
    185         mRingtone.setAudioAttributes(ringtoneAa);
    186         assertEquals(ringtoneAa, mRingtone.getAudioAttributes());
    187         mRingtone.setLooping(true);
    188         mRingtone.setVolume(0.5f);
    189         mRingtone.play();
    190         assertTrue("couldn't play ringtone " + uri, mRingtone.isPlaying());
    191         assertTrue(mRingtone.isLooping());
    192         assertEquals("invalid ringtone player volume", 0.5f, mRingtone.getVolume());
    193         mRingtone.stop();
    194         assertFalse(mRingtone.isPlaying());
    195     }
    196 }
    197