Project: android_packages_wallpapers_MusicVisualization
/*
 * Copyright (C) 2009 The Android Open Source Project 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */
 
package com.android.musicvis.vis1; 
 
import com.android.musicvis.AudioCapture; 
 
import android.graphics.Canvas; 
import android.graphics.Paint; 
import android.graphics.Rect; 
import android.media.MediaPlayer; 
import android.os.Handler; 
import android.os.SystemClock; 
import android.service.wallpaper.WallpaperService; 
import android.util.Log; 
import android.view.MotionEvent; 
import android.view.SurfaceHolder; 
 
import java.util.Arrays; 
 
public class Visualization1 extends WallpaperService { 
 
    private final Handler mHandler = new Handler(); 
 
    @Override 
    public void onCreate() { 
        super.onCreate(); 
    } 
 
    @Override 
    public void onDestroy() { 
        super.onDestroy(); 
    } 
 
    @Override 
    public Engine onCreateEngine() { 
        return new CubeEngine(); 
    } 
 
    class CubeEngine extends Engine { 
 
        private final Paint mPaint = new Paint(); 
        private float mOffset; 
        private float mTouchX = -1
        private float mTouchY = -1
        private long mStartTime; 
        private int mWidth; 
        private float mCenterX; 
        private float mCenterY; 
        private AudioCapture mAudioCapture; 
        private int [] mVizData = new int[1024]; 
 
        private final Runnable mDrawCube = new Runnable() { 
            public void run() { 
                drawFrame(); 
            } 
        }; 
        private boolean mVisible; 
 
        CubeEngine() { 
        } 
 
        @Override 
        public void onCreate(SurfaceHolder surfaceHolder) { 
            super.onCreate(surfaceHolder); 
 
            final Paint paint = mPaint; 
            paint.setColor(0xffffffff); 
            paint.setAntiAlias(true); 
            paint.setStrokeWidth(2); 
            paint.setStrokeCap(Paint.Cap.ROUND); 
            paint.setStyle(Paint.Style.STROKE); 
 
            mStartTime = SystemClock.elapsedRealtime(); 
        } 
 
        @Override 
        public void onDestroy() { 
            super.onDestroy(); 
            mHandler.removeCallbacks(mDrawCube); 
            if (mAudioCapture != null) { 
                mAudioCapture.stop(); 
                mAudioCapture.release(); 
                mAudioCapture = null
            } 
        } 
 
        @Override 
        public void onVisibilityChanged(boolean visible) { 
            mVisible = visible; 
            if (visible) { 
                if (mAudioCapture == null) { 
                    mAudioCapture = new AudioCapture(AudioCapture.TYPE_PCM, 1024); 
                } 
                mAudioCapture.start(); 
                drawFrame(); 
            } else { 
                mHandler.removeCallbacks(mDrawCube); 
                if (mAudioCapture != null) { 
                    mAudioCapture.stop(); 
                    mAudioCapture.release(); 
                    mAudioCapture = null
                } 
            } 
        } 
 
        @Override 
        public void onSurfaceChanged(SurfaceHolder holder, int format, int width, int height) { 
            super.onSurfaceChanged(holder, format, width, height); 
            mWidth = width; 
            mCenterX = width/2.0f
            mCenterY = height/2.0f
            drawFrame(); 
        } 
 
        @Override 
        public void onSurfaceCreated(SurfaceHolder holder) { 
            super.onSurfaceCreated(holder); 
        } 
 
        @Override 
        public void onSurfaceDestroyed(SurfaceHolder holder) { 
            super.onSurfaceDestroyed(holder); 
            mVisible = false
            mHandler.removeCallbacks(mDrawCube); 
        } 
 
        @Override 
        public void onOffsetsChanged(float xOffset, float yOffset, 
                float xStep, float yStep, int xPixels, int yPixels) { 
            mOffset = xOffset; 
            drawFrame(); 
        } 
 
        @Override 
        public void onTouchEvent(MotionEvent event) { 
            // touch events don't actually work for wallpapers, but if they did, 
            // we'd be using them to draw a circle around the touch point 
            if (event.getAction() == MotionEvent.ACTION_MOVE) { 
                mTouchX = event.getX(); 
                mTouchY = event.getY(); 
            } else { 
                mTouchX = -1
                mTouchY = -1
            } 
            super.onTouchEvent(event); 
        } 
 
        void drawFrame() { 
            final SurfaceHolder holder = getSurfaceHolder(); 
            final Rect frame = holder.getSurfaceFrame(); 
            final int width = frame.width(); 
            final int height = frame.height(); 
 
            Canvas c = null
            try { 
                c = holder.lockCanvas(); 
                if (c != null) { 
                    // draw something 
                    drawCube(c); 
                    drawTouchPoint(c); 
                } 
            } finally { 
                if (c != null) holder.unlockCanvasAndPost(c); 
            } 
 
            mHandler.removeCallbacks(mDrawCube); 
            if (mVisible) { 
                mHandler.postDelayed(mDrawCube, 1000 / 25); 
            } 
        } 
 
        void drawCube(Canvas c) { 
            c.save(); 
            c.drawColor(0xff000000); 
 
            if (mAudioCapture != null) { 
                mVizData = mAudioCapture.getFormattedData(11); 
            } else { 
                Arrays.fill(mVizData, (int)0); 
            } 
 
            for (int i = 0; i < mWidth; i++) { 
                c.drawPoint(i, mCenterY + mVizData[i], mPaint); 
            } 
            c.restore(); 
        } 
 
        void drawTouchPoint(Canvas c) { 
            if (mTouchX >=0 && mTouchY >= 0) { 
                c.drawCircle(mTouchX, mTouchY, 50, mPaint); 
            } 
        } 
 
    } 
}