From 0422aa111d12b98bd52975b640837648fa1192e2 Mon Sep 17 00:00:00 2001
From: Danny Baumann <dannybaumann@web.de>
Date: Sat, 2 Jun 2012 12:38:25 +0200
Subject: [PATCH] Increasing ringtone volume option (3/3)

Change-Id: I40576dcc603c836d62e65fb144e2d920fd407826
---
 src/com/android/phone/Ringer.java | 77 +++++++++++++++++++++++++++++--
 1 file changed, 72 insertions(+), 5 deletions(-)

diff --git a/src/com/android/phone/Ringer.java b/src/com/android/phone/Ringer.java
index 17b081d4e..95b3b273d 100644
--- a/src/com/android/phone/Ringer.java
+++ b/src/com/android/phone/Ringer.java
@@ -16,6 +16,7 @@
 
 package com.android.phone;
 
+import android.content.ContentResolver;
 import android.content.Context;
 import android.media.AudioManager;
 import android.media.Ringtone;
@@ -44,6 +45,7 @@ public class Ringer {
 
     private static final int PLAY_RING_ONCE = 1;
     private static final int STOP_RING = 3;
+    private static final int INCREASE_RING_VOLUME = 4;
 
     private static final int VIBRATE_LENGTH = 1000; // ms
     private static final int PAUSE_LENGTH = 1000; // ms
@@ -53,17 +55,22 @@ public class Ringer {
 
     Ringtone mRingtone;
     Vibrator mVibrator = new Vibrator();
+    AudioManager mAudioManager;
     IPowerManager mPowerManager;
     volatile boolean mContinueVibrating;
     VibratorThread mVibratorThread;
     Context mContext;
     private Worker mRingThread;
+    private Handler mHandler;
     private Handler mRingHandler;
     private long mFirstRingEventTime = -1;
     private long mFirstRingStartTime = -1;
+    private int mRingerVolumeSetting;
+    private int mRingIncreaseInterval;
 
     Ringer(Context context) {
         mContext = context;
+        mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
         mPowerManager = IPowerManager.Stub.asInterface(ServiceManager.getService(Context.POWER_SERVICE));
     }
 
@@ -141,17 +148,42 @@ void ring() {
                 if (DBG) log("- starting vibrator...");
                 mVibratorThread.start();
             }
-            AudioManager audioManager =
-                    (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
 
-            if (audioManager.getStreamVolume(AudioManager.STREAM_RING) == 0) {
+            int ringerVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_RING);
+            if (ringerVolume == 0 && mRingerVolumeSetting <= 0) {
                 if (DBG) log("skipping ring because volume is zero");
                 return;
             }
 
             makeLooper();
+            mHandler.removeCallbacksAndMessages(null);
             mRingHandler.removeCallbacksAndMessages(null);
             if (mFirstRingEventTime < 0) {
+                ContentResolver cr = mContext.getContentResolver();
+                boolean increasing = Settings.System.getInt(cr,
+                        Settings.System.INCREASING_RING, 0) == 1;
+
+                if (increasing) {
+                    int minVolume = Settings.System.getInt(cr,
+                            Settings.System.INCREASING_RING_MIN_VOLUME, 1);
+
+                    mRingIncreaseInterval = Settings.System.getInt(cr,
+                            Settings.System.INCREASING_RING_INTERVAL, 0);
+
+                    mRingerVolumeSetting = ringerVolume;
+                    mAudioManager.setStreamVolume(AudioManager.STREAM_RING, minVolume, 0);
+                    if (DBG) {
+                        log("increasing ring is enabled, starting at " +
+                                minVolume + "/" + ringerVolume);
+                    }
+                    if (mRingIncreaseInterval > 0) {
+                        mHandler.sendEmptyMessageDelayed(
+                                INCREASE_RING_VOLUME, mRingIncreaseInterval);
+                    }
+                } else {
+                    mRingerVolumeSetting = -1;
+                }
+
                 mFirstRingEventTime = SystemClock.elapsedRealtime();
                 mRingHandler.sendEmptyMessage(PLAY_RING_ONCE);
             } else {
@@ -164,6 +196,9 @@ void ring() {
                     if (DBG) {
                         log("delaying ring by " + (mFirstRingStartTime - mFirstRingEventTime));
                     }
+                    if (mRingerVolumeSetting > 0 && mRingIncreaseInterval == 0) {
+                        mHandler.sendEmptyMessage(INCREASE_RING_VOLUME);
+                    }
                     mRingHandler.sendEmptyMessageDelayed(PLAY_RING_ONCE,
                             mFirstRingStartTime - mFirstRingEventTime);
                 } else {
@@ -177,8 +212,7 @@ void ring() {
     }
 
     boolean shouldVibrate() {
-        AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
-        return audioManager.shouldVibrate(AudioManager.VIBRATE_TYPE_RINGER);
+        return mAudioManager.shouldVibrate(AudioManager.VIBRATE_TYPE_RINGER);
     }
 
     /**
@@ -195,6 +229,15 @@ void stopRing() {
                 // the other end of this binder call is in the system process.
             }
 
+            if (mHandler != null) {
+                mHandler.removeCallbacksAndMessages(null);
+                mHandler = null;
+            }
+            if (mRingerVolumeSetting >= 0) {
+                if (DBG) log("- stopRing: resetting ring volume to " + mRingerVolumeSetting);
+                mAudioManager.setStreamVolume(AudioManager.STREAM_RING, mRingerVolumeSetting, 0);
+                mRingerVolumeSetting = -1;
+            }
             if (mRingHandler != null) {
                 mRingHandler.removeCallbacksAndMessages(null);
                 Message msg = mRingHandler.obtainMessage(STOP_RING);
@@ -275,6 +318,30 @@ void setCustomRingtoneUri (Uri uri) {
     }
 
     private void makeLooper() {
+        if (mHandler == null) {
+            mHandler = new Handler() {
+                @Override
+                public void handleMessage(Message msg) {
+                    switch (msg.what) {
+                        case INCREASE_RING_VOLUME:
+                            int ringerVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_RING);
+                            if (mRingerVolumeSetting > 0 && ringerVolume < mRingerVolumeSetting) {
+                                ringerVolume++;
+                                if (DBG) {
+                                    log("increasing ring volume to " +
+                                            ringerVolume + "/" + mRingerVolumeSetting);
+                                }
+                                mAudioManager.setStreamVolume(AudioManager.STREAM_RING, ringerVolume, 0);
+                                if (mRingIncreaseInterval > 0) {
+                                    sendEmptyMessageDelayed(INCREASE_RING_VOLUME, mRingIncreaseInterval);
+                                }
+                            }
+                            break;
+                    }
+                }
+            };
+        }
+
         if (mRingThread == null) {
             mRingThread = new Worker("ringer");
             mRingHandler = new Handler(mRingThread.getLooper()) {