Audio analyzer source code

/** * org.hermit.android.core: useful Android foundation classes. * * These classes are designed to help build various types of application. * * <br>Copyright 2009-2010 Ian Cameron Smith * * <p>This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 * as published by the Free Software Foundation (see COPYING). * * <p>This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. */ package org.hermit.android.core; import org.hermit.utils.CharFormatter; import android.content.Context; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Paint; import android.graphics.PixelFormat; import android.graphics.Typeface; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.util.AttributeSet; import android.util.Log; import android.view.SurfaceHolder; import android.view.SurfaceView; /** * Common base for applications with an animated view. This class can be * used in games etc. It handles all the setup states of a SurfaceView, * and provides a Thread which the app can use to manage the animation. * * <p>When using this class in an app, the app context <b>must</b> call * these methods (usually from its corresponding Activity methods): * * <ul> * <li>{@link #onStart()} * <li>{@link #onResume()} * <li>{@link #onPause()} * <li>{@link #onStop()} * </ul> * * <p>The surface is enabled once it is created and sized, and * {@link #onStart()} and {@link #onResume()} have been called. You then * start and stop it by calling {@link #surfaceStart()} and * {@link #surfaceStop()}. */ public abstract class SurfaceRunner extends SurfaceView implements SurfaceHolder.Callback { // ******************************************************************** // // Public Constants. // ******************************************************************** // /** * Surface runner option: handle configuration changes dynamically. * If set, configuration changes such as screen orientation changes * will be passed up to the app; otherwise, it is assumed that we * will re-start for these. */ public static final int SURFACE_DYNAMIC = 0x0001; /** * Surface runner option: use a Looper to drive animations. * This allows asynchronous updates to be posted by the app. */ public static final int LOOPED_TICKER = 0x0002; // ******************************************************************** // // Constructor. // ******************************************************************** // /** * Create a SurfaceRunner instance. * * @param app The application context we're running in. */ public SurfaceRunner(Context app) { super(app); init(app, 0); } /** * Create a SurfaceRunner instance. * * @param app The application context we're running in. * @param options Options for this SurfaceRunner. A bitwise OR of * SURFACE_XXX constants. */ public SurfaceRunner(Context app, int options) { super(app); init(app, options); } /** * Create a SurfaceRunner instance. * * @param app The application context we're running in. * @param attrs Layout attributes for this SurfaceRunner. */ public SurfaceRunner(Context app, AttributeSet attrs) { super(app, attrs); init(app, 0); } /** * Initialize this SurfaceRunner instance. * * @param app The application context we're running in. * @param options Options for this SurfaceRunner. A bitwise OR of * SURFACE_XXX constants. */ private void init(Context app, int options) { appContext = app; errorReporter = Errors.getInstance(app); surfaceOptions = options; animationDelay = 0; // Register for events on the surface. surfaceHolder = getHolder(); surfaceHolder.addCallback(this); setFocusable(true); setFocusableInTouchMode(true); // Workaround for edge fading -- sometimes after repeated orientation // changes one edge will fade; this fixes it. setHorizontalFadingEdgeEnabled(false); setVerticalFadingEdgeEnabled(false); } // ******************************************************************** // // Configuration. // ******************************************************************** // /** * Check whether the given option flag is set on this surface. * * @param option The option flag to test; one of SURFACE_XXX. * @return true iff the option is set. */ public boolean optionSet(int option) { return (surfaceOptions & option) != 0; } // ******************************************************************** // // State Handling. // ******************************************************************** // /** * Set the delay in ms in each iteration of the main loop. * * @param delay The time in ms to sleep each time round the main * animation loop. If zero, we will not sleep, * but will run continuously. * * <p>If you want to do all your animation under * direct app control using {@link #postUpdate()}, * just set a large delay. You may want to consider * using 1000 -- i.e. one second -- to make sure * you get a refresh at a decent interval. */ public void setDelay(long delay) { Log.i(TAG, "setDelay " + delay); animationDelay = delay; } /** * This is called immediately after the surface is first created. * Implementations of this should start up whatever rendering code * they desire. * * Note that only one thread can ever draw into a Surface, so you * should not draw into the Surface here if your normal rendering * will be in another thread. * * @param holder The SurfaceHolder whose surface is being created. */ @Override public void surfaceCreated(SurfaceHolder holder) { setEnable(ENABLE_SURFACE, "surfaceCreated"); } /** * This is called immediately after any structural changes (format or * size) have been made to the surface. This method is always * called at least once, after surfaceCreated(SurfaceHolder). * * @param holder The SurfaceHolder whose surface has changed. * @param format The new PixelFormat of the surface. * @param width The new width of the surface. * @param height The new height of the surface. */ @Override public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { // On Droid (at least) this can get called after a rotation, // which shouldn't happen as we should get shut down first. // Ignore that, unless we're handling config changes dynamically. if (!optionSet(SURFACE_DYNAMIC) && isEnable(ENABLE_SIZE)) { Log.e(TAG, "ignored surfaceChanged " + width + "x" + height); return; } setSize(format, width, height); setEnable(ENABLE_SIZE, "set size " + width + "x" + height); } /** * This is called immediately before a surface is destroyed. * After returning from this call, you should no longer try to * access this surface. If you have a