Thing

package com.nix.test.AutoStart.service;

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import com.nix.test.AutoStart.PhoneStateReceiver;

import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.media.AudioManager;
import android.media.ToneGenerator;
import android.os.IBinder;
import android.os.Vibrator;
import android.util.Log;

import com.nix.java.audio.MicUtil;


public class StatusUpdateService extends Service {

    @Override
    public IBinder onBind(Intent intent) {
        // TODO Auto-generated method stub
        //new ToneGenerator(AudioManager.STREAM_MUSIC, ToneGenerator.MAX_VOLUME>>1).startTone(ToneGenerator.TONE_DTMF_8, 5000);
        return null;
    }

    @Override
    public void onCreate() {
        mic = new MicUtil();
    }

    private ScheduledExecutorService _exec;

    private ScheduledExecutorService _execShutdown;

    private String lastKnownCallState;

    private MicUtil mic;

    private double totalDb; //the total DB

    private short dbSampleCount; //the total number of DB samples taken

    private double dbAvg = 0; //average DB

    private long initTimeMs; // the time this call was initiated

    final public static int SERVICE_STATE_GETTING_AVG   = 1;
    final public static int SERVICE_STATE_AWAITING_VOICE = 2;
    final public static int SERVICE_STATE_ALERT_INTERVAL = 3;


    private int serviceState;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        String action = intent.getAction();

        lastKnownCallState = action;

        Log.d("SERVICE", "onStartCommand " + action);

        if(action.equals(PhoneStateReceiver.INITIAL_START)){
            resetValues();
            Log.d("SERVICE", "Service started @" + initTimeMs);
        } else if (action.equals(PhoneStateReceiver.CALL_OFFHOOK)){
            Log.d("SERVICE", "Call offhook");
            serviceState = SERVICE_STATE_GETTING_AVG;
            setInterval();
        } else if (action.equals(PhoneStateReceiver.CALL_IDLE)){
             Log.d("SERVICE", "Call idle");
             setIntervalShutDown();
        }

        return START_STICKY;
     }

    private void resetValues(){
        initTimeMs = new Date().getTime();
        totalDb = 0;
        dbSampleCount = 0;
        dbAvg = 0;
    }

    private void interval(){
        Log.d("SERVICE", "interval, last know state: " + lastKnownCallState);
        if(lastKnownCallState.equals(PhoneStateReceiver.CALL_OFFHOOK)){
            //Log.d("SERVICE", "BEEP!");
            setInterval();
        } else {
            setIntervalShutDown();
        }
    }

    public void setInterval(){

        Log.d("SERVICE", "setInterval");
        Runnable runnable = new Runnable() {
            public void run() {
                // TODO make class property? re-use runnable?
                interval();
            }
        };


        if(_exec == null || _exec.isShutdown() ){
            Log.d("SERVICE", "Build scheduler");
            _exec = Executors.newScheduledThreadPool(1);
        };

        long delay = 1000;
        double db;

        switch(serviceState){
        case SERVICE_STATE_GETTING_AVG:
            db = getDbLevel();
            totalDb += db;
            dbSampleCount++;
            Log.d("SERVICE", "SERVICE_STATE_GETTING_AVG, totalDb:" + totalDb + ", dbSampleCount:" + dbSampleCount);
            if(dbSampleCount > 10){
                //double avg = totalDb / dbSampleCount;
                serviceState = SERVICE_STATE_AWAITING_VOICE;
                dbAvg = totalDb / dbSampleCount;
                Log.d("SERVICE", "10 samples calculated! :) avg:" + dbAvg);
            }
            delay = 250;
            break;
        case SERVICE_STATE_AWAITING_VOICE:
            Date date = new Date();
            if(date.getTime() > initTimeMs + (max_voiceWaitTime() * 1000 ) ){
                Log.d("SERVICE", "max time exceeded");
                serviceState = SERVICE_STATE_ALERT_INTERVAL;
            } else {
                db = getDbLevel();
                Log.d("SERVICE", "SERVICE_STATE_AWAITING_VOICE, current db:" + db + ", avg:" + dbAvg);
                if(db > (dbAvg + 11) ) {
                    Log.d("SERVICE", "average exceeded! :)");
                    serviceState = SERVICE_STATE_ALERT_INTERVAL;
                }
            }
            delay = 500;
            break;
        case SERVICE_STATE_ALERT_INTERVAL:
            Log.d("SERVICE", "SERVICE_STATE_ALERT_INTERVAL");
            alertInterval();
            delay = next_AlertInterval() * 1000;
            break;
        }

        Log.d("SERVICE", "Schedule new task");
        _exec.schedule(runnable, delay, TimeUnit.MILLISECONDS);

    }

    public void alertInterval(){
        Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);

        // 1. Vibrate for 1000 milliseconds
        long milliseconds = 50;
        v.vibrate(milliseconds);

        new ToneGenerator(AudioManager.STREAM_VOICE_CALL, 100/*TODO make option variable*/).startTone(ToneGenerator.TONE_DTMF_4, 500);
    }

    public int next_AlertInterval(){
        //Todo: get "alert seconds before minute"(x) from settings, to 60-(x)
        return 50;
    }

    public int max_voiceWaitTime(){
        //Todo read from local settings
        return 15;
    }

    public void setIntervalShutDown(){
        if(_execShutdown != null){
            _execShutdown.shutdownNow(); //cancel current shutdown taksk to reset the timer
        }

        _execShutdown = Executors.newScheduledThreadPool(1); //always create a new shutdown thread

        Runnable runnable = new Runnable() {

            public void run() {
                // TODO Auto-generated method stub
                Log.d("SERVICE", "Start shutdown task");
                intervalShutdown();
            }
        };

        _execShutdown.schedule(runnable, 4, TimeUnit.SECONDS);

    }

    public void intervalShutdown(){

        Log.d("SERVICE", "intervalShutdown");
         _exec.shutdownNow(); //stop tasks
         _execShutdown.shutdownNow();
         stopSelf(); // stop service
    }

    private double getDbLevel(){
        double db = mic.getDB();
        Log.d("SERVICE", "DB:"  + db);
        return db;
    }

}