'Android' 카테고리의 글 목록 (2 Page)

/*
* Copyright (C) 2006 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 android.media;

import android.content.ContentResolver;
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.ParcelFileDescriptor;
import android.os.PowerManager;
import android.util.Log;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.graphics.Bitmap;
import android.media.AudioManager;

import java.io.FileDescriptor;
import java.io.IOException;

import java.lang.ref.WeakReference;

/**
* MediaPlayer class can be used to control playback
* of audio/video files and streams. An example on how to use the methods in
* this class can be found in {@link android.widget.VideoView}.
* Please see <a href="{@docRoot}guide/topics/media/index.html">Audio and Video</a>
* for additional help using MediaPlayer.
*
* Topics covered here are:
* <ol>
* <li><a href="#StateDiagram">State Diagram</a>
* <li><a href="#Valid_and_Invalid_States">Valid and Invalid States</a>
* <li><a href="#Permissions">Permissions</a>
* </ol>
*
* <a name="StateDiagram"></a>
* <h3>State Diagram</h3>
*
* Playback control of audio/video files and streams is managed as a state
* machine. The following diagram shows the life cycle and the states of a
* MediaPlayer object driven by the supported playback control operations.
* The ovals represent the states a MediaPlayer object may reside
* in. The arcs represent the playback control operations that drive the object
* state transition. There are two types of arcs. The arcs with a single arrow
* head represent synchronous method calls, while those with
* a double arrow head represent asynchronous method calls.
*
* <img src="../../../images/mediaplayer_state_diagram.gif"
* alt="MediaPlayer State diagram"
* border="0" />
*
* From this state diagram, one can see that a MediaPlayer object has the
* following states:
* <ul>
* <li>When a MediaPlayer object is just created using <code>new</code> or
* after {@link #reset()} is called, it is in the Idle state; and after
* {@link #release()} is called, it is in the End state. Between these
* two states is the life cycle of the MediaPlayer object.
* <ul>
* <li>There is a subtle but important difference between a newly constructed
* MediaPlayer object and the MediaPlayer object after {@link #reset()}
* is called. It is a programming error to invoke methods such
* as {@link #getCurrentPosition()},
* {@link #getDuration()}, {@link #getVideoHeight()},
* {@link #getVideoWidth()}, {@link #setAudioStreamType(int)},
* {@link #setLooping(boolean)},
* {@link #setVolume(float, float)}, {@link #pause()}, {@link #start()},
* {@link #stop()}, {@link #seekTo(int)}, {@link #prepare()} or
* {@link #prepareAsync()} in the Idle state for both cases. If any of these
* methods is called right after a MediaPlayer object is constructed,
* the user supplied callback method OnErrorListener.onError() won't be
* called by the internal player engine and the object state remains
* unchanged; but if these methods are called right after {@link #reset()},
* the user supplied callback method OnErrorListener.onError() will be
* invoked by the internal player engine and the object will be
* transfered to the Error state. </li>
* <li>It is also recommended that once
* a MediaPlayer object is no longer being used, call {@link #release()} immediately
* so that resources used by the internal player engine associated with the
* MediaPlayer object can be released immediately. Resource may include
* singleton resources such as hardware acceleration components and
* failure to call {@link #release()} may cause subsequent instances of
* MediaPlayer objects to fallback to software implementations or fail
* altogether. Once the MediaPlayer
* object is in the End state, it can no longer be used and
* there is no way to bring it back to any other state. </li>
* <li>Furthermore,
* the MediaPlayer objects created using <code>new</code> is in the
* Idle state, while those created with one
* of the overloaded convenient <code>create</code> methods are NOT
* in the Idle state. In fact, the objects are in the Prepared
* state if the creation using <code>create</code> method is successful.
* </li>
* </ul>
* </li>
* <li>In general, some playback control operation may fail due to various
* reasons, such as unsupported audio/video format, poorly interleaved
* audio/video, resolution too high, streaming timeout, and the like.
* Thus, error reporting and recovery is an important concern under
* these circumstances. Sometimes, due to programming errors, invoking a playback
* control operation in an invalid state may also occur. Under all these
* error conditions, the internal player engine invokes a user supplied
* OnErrorListener.onError() method if an OnErrorListener has been
* registered beforehand via
* {@link #setOnErrorListener(android.media.MediaPlayer.OnErrorListener)}.
* <ul>
* <li>It is important to note that once an error occurs, the
* MediaPlayer object enters the Error state (except as noted
* above), even if an error listener has not been registered by the application.</li>
* <li>In order to reuse a MediaPlayer object that is in the 
* Error state and recover from the error,
* {@link #reset()} can be called to restore the object to its Idle
* state.</li>
* <li>It is good programming practice to have your application
* register a OnErrorListener to look out for error notifications from
* the internal player engine.</li>
* <li>IlleglStateException is
* thrown to prevent programming errors such as calling {@link #prepare()},
* {@link #prepareAsync()}, or one of the overloaded <code>setDataSource
* </code> methods in an invalid state. </li>
* </ul>
* </li>
* <li>Calling
* {@link #setDataSource(FileDescriptor)}, or
* {@link #setDataSource(String)}, or
* {@link #setDataSource(Context, Uri)}, or
* {@link #setDataSource(FileDescriptor, long, long)} transfers a
* MediaPlayer object in the Idle state to the
* Initialized state.
* <ul>
* <li>An IllegalStateException is thrown if
* setDataSource() is called in any other state.</li>
* <li>It is good programming
* practice to always look out for <code>IllegalArgumentException</code>
* and <code>IOException</code> that may be thrown from the overloaded
* <code>setDataSource</code> methods.</li>
* </ul>
* </li>
* <li>A MediaPlayer object must first enter the Prepared state
* before playback can be started.
* <ul>
* <li>There are two ways (synchronous vs.
* asynchronous) that the Prepared state can be reached:
* either a call to {@link #prepare()} (synchronous) which
* transfers the object to the Prepared state once the method call
* returns, or a call to {@link #prepareAsync()} (asynchronous) which
* first transfers the object to the Preparing state after the
* call returns (which occurs almost right way) while the internal
* player engine continues working on the rest of preparation work
* until the preparation work completes. When the preparation completes or when {@link #prepare()} call returns,
* the internal player engine then calls a user supplied callback method,
* onPrepared() of the OnPreparedListener interface, if an
* OnPreparedListener is registered beforehand via {@link
* #setOnPreparedListener(android.media.MediaPlayer.OnPreparedListener)}.</li>
* <li>It is important to note that
* the Preparing state is a transient state, and the behavior
* of calling any method with side effect while a MediaPlayer object is
* in the Preparing state is undefined.</li>
* <li>An IllegalStateException is
* thrown if {@link #prepare()} or {@link #prepareAsync()} is called in
* any other state.</li>
* <li>While in the Prepared state, properties
* such as audio/sound volume, screenOnWhilePlaying, looping can be
* adjusted by invoking the corresponding set methods.</li>
* </ul>
* </li>
* <li>To start the playback, {@link #start()} must be called. After
* {@link #start()} returns successfully, the MediaPlayer object is in the
* Started state. {@link #isPlaying()} can be called to test
* whether the MediaPlayer object is in the Started state.
* <ul>
* <li>While in the Started state, the internal player engine calls
* a user supplied OnBufferingUpdateListener.onBufferingUpdate() callback
* method if a OnBufferingUpdateListener has been registered beforehand
* via {@link #setOnBufferingUpdateListener(OnBufferingUpdateListener)}.
* This callback allows applications to keep track of the buffering status
* while streaming audio/video.</li>
* <li>Calling {@link #start()} has not effect
* on a MediaPlayer object that is already in the Started state.</li>
* </ul>
* </li>
* <li>Playback can be paused and stopped, and the current playback position
* can be adjusted. Playback can be paused via {@link #pause()}. When the call to
* {@link #pause()} returns, the MediaPlayer object enters the
* Paused state. Note that the transition from the Started
* state to the Paused state and vice versa happens
* asynchronously in the player engine. It may take some time before
* the state is updated in calls to {@link #isPlaying()}, and it can be
* a number of seconds in the case of streamed content.
* <ul>
* <li>Calling {@link #start()} to resume playback for a paused
* MediaPlayer object, and the resumed playback
* position is the same as where it was paused. When the call to
* {@link #start()} returns, the paused MediaPlayer object goes back to
* the Started state.</li>
* <li>Calling {@link #pause()} has no effect on
* a MediaPlayer object that is already in the Paused state.</li>
* </ul>
* </li>
* <li>Calling {@link #stop()} stops playback and causes a
* MediaPlayer in the Started, Paused, Prepared
* or PlaybackCompleted state to enter the
* Stopped state.
* <ul>
* <li>Once in the Stopped state, playback cannot be started
* until {@link #prepare()} or {@link #prepareAsync()} are called to set
* the MediaPlayer object to the Prepared state again.</li>
* <li>Calling {@link #stop()} has no effect on a MediaPlayer
* object that is already in the Stopped state.</li>
* </ul>
* </li>
* <li>The playback position can be adjusted with a call to
* {@link #seekTo(int)}.
* <ul>
* <li>Although the asynchronuous {@link #seekTo(int)}
* call returns right way, the actual seek operation may take a while to
* finish, especially for audio/video being streamed. When the actual
* seek operation completes, the internal player engine calls a user
* supplied OnSeekComplete.onSeekComplete() if an OnSeekCompleteListener
* has been registered beforehand via
* {@link #setOnSeekCompleteListener(OnSeekCompleteListener)}.</li>
* <li>Please
* note that {@link #seekTo(int)} can also be called in the other states,
* such as Prepared, Paused and PlaybackCompleted
* state.</li>
* <li>Furthermore, the actual current playback position
* can be retrieved with a call to {@link #getCurrentPosition()}, which
* is helpful for applications such as a Music player that need to keep
* track of the playback progress.</li>
* </ul>
* </li>
* <li>When the playback reaches the end of stream, the playback completes.
* <ul>
* <li>If the looping mode was being set to <var>true</var>with
* {@link #setLooping(boolean)}, the MediaPlayer object shall remain in
* the Started state.</li>
* <li>If the looping mode was set to <var>false
* </var>, the player engine calls a user supplied callback method,
* OnCompletion.onCompletion(), if a OnCompletionListener is registered
* beforehand via {@link #setOnCompletionListener(OnCompletionListener)}.
* The invoke of the callback signals that the object is now in the 
* PlaybackCompleted state.</li>
* <li>While in the PlaybackCompleted
* state, calling {@link #start()} can restart the playback from the
* beginning of the audio/video source.</li>
* </ul>
*
*
* <a name="Valid_and_Invalid_States"></a>
* <h3>Valid and invalid states</h3>
*
* <table border="0" cellspacing="0" cellpadding="0">
* <tr><td>Method Name </td>
* <td>Valid Sates </td>
* <td>Invalid States </td>
* <td>Comments </td></tr>
* <tr><td>getCurrentPosition </td>
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
* PlaybackCompleted} </td>
* <td>{Error}</td>
* <td>Successful invoke of this method in a valid state does not change the
* state. Calling this method in an invalid state transfers the object
* to the Error state. </td></tr>
* <tr><td>getDuration </td>
* <td>{Prepared, Started, Paused, Stopped, PlaybackCompleted} </td>
* <td>{Idle, Initialized, Error} </td>
* <td>Successful invoke of this method in a valid state does not change the
* state. Calling this method in an invalid state transfers the object
* to the Error state. </td></tr>
* <tr><td>getVideoHeight </td>
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
* PlaybackCompleted}</td>
* <td>{Error}</td>
* <td>Successful invoke of this method in a valid state does not change the
* state. Calling this method in an invalid state transfers the object
* to the Error state. </td></tr>
* <tr><td>getVideoWidth </td>
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
* PlaybackCompleted}</td>
* <td>{Error}</td>
* <td>Successful invoke of this method in a valid state does not change
* the state. Calling this method in an invalid state transfers the
* object to the Error state. </td></tr>
* <tr><td>isPlaying </td>
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
* PlaybackCompleted}</td>
* <td>{Error}</td>
* <td>Successful invoke of this method in a valid state does not change
* the state. Calling this method in an invalid state transfers the
* object to the Error state. </td></tr>
* <tr><td>pause </td>
* <td>{Started, Paused}</td>
* <td>{Idle, Initialized, Prepared, Stopped, PlaybackCompleted, Error}</td>
* <td>Successful invoke of this method in a valid state transfers the
* object to the Paused state. Calling this method in an
* invalid state transfers the object to the Error state.</td></tr>
* <tr><td>prepare </td>
* <td>{Initialized, Stopped} </td>
* <td>{Idle, Prepared, Started, Paused, PlaybackCompleted, Error} </td>
* <td>Successful invoke of this method in a valid state transfers the
* object to the Prepared state. Calling this method in an
* invalid state throws an IllegalStateException.</td></tr>
* <tr><td>prepareAsync </td>
* <td>{Initialized, Stopped} </td>
* <td>{Idle, Prepared, Started, Paused, PlaybackCompleted, Error} </td>
* <td>Successful invoke of this method in a valid state transfers the
* object to the Preparing state. Calling this method in an
* invalid state throws an IllegalStateException.</td></tr>
* <tr><td>release </td>
* <td>any </td>
* <td>{} </td>
* <td>After {@link #release()}, the object is no longer available. </td></tr>
* <tr><td>reset </td>
* <td>{Idle, Initialized, Prepared, Started, Paused, Stopped,
* PlaybackCompleted, Error}</td>
* <td>{}</td>
* <td>After {@link #reset()}, the object is like being just created.</td></tr>
* <tr><td>seekTo </td>
* <td>{Prepared, Started, Paused, PlaybackCompleted} </td>
* <td>{Idle, Initialized, Stopped, Error}</td>
* <td>Successful invoke of this method in a valid state does not change
* the state. Calling this method in an invalid state transfers the
* object to the Error state. </td></tr>
* <tr><td>setAudioStreamType </td>
* <td>{Idle, Initialized, Stopped, Prepared, Started, Paused,
* PlaybackCompleted}</td>
* <td>{Error}</td>
* <td>Successful invoke of this method does not change the state.</td></tr>
* <tr><td>setDataSource </td>
* <td>{Idle} </td>
* <td>{Initialized, Prepared, Started, Paused, Stopped, PlaybackCompleted,
* Error} </td>
* <td>Successful invoke of this method in a valid state transfers the
* object to the Initialized state. Calling this method in an
* invalid state throws an IllegalStateException.</td></tr>
* <tr><td>setDisplay </td>
* <td>any </td>
* <td>{} </td>
* <td>This method can be called in any state and calling it does not change
* the object state. </td></tr>
* <tr><td>setLooping </td>
* <td>{Idle, Initialized, Stopped, Prepared, Started, Paused,
* PlaybackCompleted}</td>
* <td>{Error}</td>
* <td>Successful invoke of this method in a valid state does not change
* the state. Calling this method in an
* invalid state transfers the object to the Error state.</td></tr>
* <tr><td>isLooping </td>
* <td>any </td>
* <td>{} </td>
* <td>This method can be called in any state and calling it does not change
* the object state. </td></tr>
* <tr><td>setOnBufferingUpdateListener </td>
* <td>any </td>
* <td>{} </td>
* <td>This method can be called in any state and calling it does not change
* the object state. </td></tr>
* <tr><td>setOnCompletionListener </td>
* <td>any </td>
* <td>{} </td>
* <td>This method can be called in any state and calling it does not change
* the object state. </td></tr>
* <tr><td>setOnErrorListener </td>
* <td>any </td>
* <td>{} </td>
* <td>This method can be called in any state and calling it does not change
* the object state. </td></tr>
* <tr><td>setOnPreparedListener </td>
* <td>any </td>
* <td>{} </td>
* <td>This method can be called in any state and calling it does not change
* the object state. </td></tr>
* <tr><td>setOnSeekCompleteListener </td>
* <td>any </td>
* <td>{} </td>
* <td>This method can be called in any state and calling it does not change
* the object state. </td></tr>
* <tr><td>setScreenOnWhilePlaying</></td>
* <td>any </td>
* <td>{} </td>
* <td>This method can be called in any state and calling it does not change
* the object state. </td></tr>
* <tr><td>setVolume </td>
* <td>{Idle, Initialized, Stopped, Prepared, Started, Paused,
* PlaybackCompleted}</td>
* <td>{Error}</td>
* <td>Successful invoke of this method does not change the state.
* <tr><td>setWakeMode </td>
* <td>any </td>
* <td>{} </td>
* <td>This method can be called in any state and calling it does not change
* the object state.</td></tr>
* <tr><td>start </td>
* <td>{Prepared, Started, Paused, PlaybackCompleted}</td>
* <td>{Idle, Initialized, Stopped, Error}</td>
* <td>Successful invoke of this method in a valid state transfers the
* object to the Started state. Calling this method in an
* invalid state transfers the object to the Error state.</td></tr>
* <tr><td>stop </td>
* <td>{Prepared, Started, Stopped, Paused, PlaybackCompleted}</td>
* <td>{Idle, Initialized, Error}</td>
* <td>Successful invoke of this method in a valid state transfers the
* object to the Stopped state. Calling this method in an
* invalid state transfers the object to the Error state.</td></tr>
* </table>
*
* <a name="Permissions"></a>
* <h3>Permissions</h3>
* One may need to declare a corresponding WAKE_LOCK permission {@link
* android.R.styleable#AndroidManifestUsesPermission <uses-permission>}
* element.
*
*/
public class MediaPlayer
{
 static {
 System.loadLibrary("media_jni");
 }

 private final static String TAG = "MediaPlayer";

 private int mNativeContext; // accessed by native methods
 private int mListenerContext; // accessed by native methods
 private Surface mSurface; // accessed by native methods
 private SurfaceHolder mSurfaceHolder;
 private EventHandler mEventHandler;
 private PowerManager.WakeLock mWakeLock = null;
 private boolean mScreenOnWhilePlaying;
 private boolean mStayAwake;

 /**
 * Default constructor. Consider using one of the create() methods for
 * synchronously instantiating a MediaPlayer from a Uri or resource.
 * When done with the MediaPlayer, you should call {@link #release()},
 * to free the resources. If not released, too many MediaPlayer instances may
 * result in an exception.
 */
 public MediaPlayer() {

 Looper looper;
 if ((looper = Looper.myLooper()) != null) {
 mEventHandler = new EventHandler(this, looper);
 } else if ((looper = Looper.getMainLooper()) != null) {
 mEventHandler = new EventHandler(this, looper);
 } else {
 mEventHandler = null;
 }

 /* Native setup requires a weak reference to our object.
 * It's easier to create it here than in C++.
 */
 native_setup(new WeakReference<MediaPlayer>(this));
 }

 /*
 * Update the MediaPlayer ISurface. Call after updating mSurface.
 */
 private native void _setVideoSurface();

 /**
 * Sets the SurfaceHolder to use for displaying the video portion of the media.
 * This call is optional. Not calling it when playing back a video will
 * result in only the audio track being played.
 *
 * @param sh the SurfaceHolder to use for video display
 */
 public void setDisplay(SurfaceHolder sh) {
 mSurfaceHolder = sh;
 if (sh != null) {
 mSurface = sh.getSurface();
 } else {
 mSurface = null;
 }
 _setVideoSurface();
 updateSurfaceScreenOn();
 }

 /**
 * Convenience method to create a MediaPlayer for a given Uri.
 * On success, {@link #prepare()} will already have been called and must not be called again.
 * When done with the MediaPlayer, you should call {@link #release()},
 * to free the resources. If not released, too many MediaPlayer instances will
 * result in an exception.
 *
 * @param context the Context to use
 * @param uri the Uri from which to get the datasource
 * @return a MediaPlayer object, or null if creation failed
 */
 public static MediaPlayer create(Context context, Uri uri) {
 return create (context, uri, null);
 }

 /**
 * Convenience method to create a MediaPlayer for a given Uri.
 * On success, {@link #prepare()} will already have been called and must not be called again.
 * When done with the MediaPlayer, you should call {@link #release()},
 * to free the resources. If not released, too many MediaPlayer instances will
 * result in an exception.
 *
 * @param context the Context to use
 * @param uri the Uri from which to get the datasource
 * @param holder the SurfaceHolder to use for displaying the video
 * @return a MediaPlayer object, or null if creation failed
 */
 public static MediaPlayer create(Context context, Uri uri, SurfaceHolder holder) {

 try {
 MediaPlayer mp = new MediaPlayer();
 mp.setDataSource(context, uri);
 if (holder != null) {
 mp.setDisplay(holder);
 }
 mp.prepare();
 return mp;
 } catch (IOException ex) {
 Log.d(TAG, "create failed:", ex);
 // fall through
 } catch (IllegalArgumentException ex) {
 Log.d(TAG, "create failed:", ex);
 // fall through
 } catch (SecurityException ex) {
 Log.d(TAG, "create failed:", ex);
 // fall through
 }

 return null;
 }

 /**
 * Convenience method to create a MediaPlayer for a given resource id.
 * On success, {@link #prepare()} will already have been called and must not be called again.
 * When done with the MediaPlayer, you should call {@link #release()},
 * to free the resources. If not released, too many MediaPlayer instances will
 * result in an exception.
 *
 * @param context the Context to use
 * @param resid the raw resource id (<var>R.raw.<something></var>) for
 * the resource to use as the datasource
 * @return a MediaPlayer object, or null if creation failed
 */
 public static MediaPlayer create(Context context, int resid) {
 try {
 AssetFileDescriptor afd = context.getResources().openRawResourceFd(resid);
 if (afd == null) return null;

 MediaPlayer mp = new MediaPlayer();
 mp.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
 afd.close();
 mp.prepare();
 return mp;
 } catch (IOException ex) {
 Log.d(TAG, "create failed:", ex);
 // fall through
 } catch (IllegalArgumentException ex) {
 Log.d(TAG, "create failed:", ex);
 // fall through
 } catch (SecurityException ex) {
 Log.d(TAG, "create failed:", ex);
 // fall through
 }
 return null;
 }

 /**
 * Sets the data source as a content Uri.
 *
 * @param context the Context to use when resolving the Uri
 * @param uri the Content URI of the data you want to play
 * @throws IllegalStateException if it is called in an invalid state
 */
 public void setDataSource(Context context, Uri uri)
 throws IOException, IllegalArgumentException, SecurityException, IllegalStateException {

 String scheme = uri.getScheme();
 if(scheme == null || scheme.equals("file")) {
 setDataSource(uri.getPath());
 return;
 }

 AssetFileDescriptor fd = null;
 try {
 ContentResolver resolver = context.getContentResolver();
 fd = resolver.openAssetFileDescriptor(uri, "r");
 if (fd == null) {
 return;
 }
 // Note: using getDeclaredLength so that our behavior is the same
 // as previous versions when the content provider is returning
 // a full file.
 if (fd.getDeclaredLength() < 0) {
 setDataSource(fd.getFileDescriptor());
 } else {
 setDataSource(fd.getFileDescriptor(), fd.getStartOffset(), fd.getDeclaredLength());
 }
 return;
 } catch (SecurityException ex) {
 } catch (IOException ex) {
 } finally {
 if (fd != null) {
 fd.close();
 }
 }
 Log.d(TAG, "Couldn't open file on client side, trying server side");
 setDataSource(uri.toString());
 return;
 }

 /**
 * Sets the data source (file-path or http/rtsp URL) to use.
 *
 * @param path the path of the file, or the http/rtsp URL of the stream you want to play
 * @throws IllegalStateException if it is called in an invalid state
 */
 public native void setDataSource(String path) throws IOException, IllegalArgumentException, IllegalStateException;

 /**
 * Sets the data source (FileDescriptor) to use. It is the caller's responsibility
 * to close the file descriptor. It is safe to do so as soon as this call returns.
 *
 * @param fd the FileDescriptor for the file you want to play
 * @throws IllegalStateException if it is called in an invalid state
 */
 public void setDataSource(FileDescriptor fd)
 throws IOException, IllegalArgumentException, IllegalStateException {
 // intentionally less than LONG_MAX
 setDataSource(fd, 0, 0x7ffffffffffffffL);
 }

 /**
 * Sets the data source (FileDescriptor) to use. The FileDescriptor must be
 * seekable (N.B. a LocalSocket is not seekable). It is the caller's responsibility
 * to close the file descriptor. It is safe to do so as soon as this call returns.
 *
 * @param fd the FileDescriptor for the file you want to play
 * @param offset the offset into the file where the data to be played starts, in bytes
 * @param length the length in bytes of the data to be played
 * @throws IllegalStateException if it is called in an invalid state
 */
 public native void setDataSource(FileDescriptor fd, long offset, long length)
 throws IOException, IllegalArgumentException, IllegalStateException;

 /**
 * Prepares the player for playback, synchronously.
 *
 * After setting the datasource and the display surface, you need to either
 * call prepare() or prepareAsync(). For files, it is OK to call prepare(),
 * which blocks until MediaPlayer is ready for playback.
 *
 * @throws IllegalStateException if it is called in an invalid state
 */
 public native void prepare() throws IOException, IllegalStateException;

 /**
 * Prepares the player for playback, asynchronously.
 *
 * After setting the datasource and the display surface, you need to either
 * call prepare() or prepareAsync(). For streams, you should call prepareAsync(),
 * which returns immediately, rather than blocking until enough data has been
 * buffered.
 *
 * @throws IllegalStateException if it is called in an invalid state
 */
 public native void prepareAsync() throws IllegalStateException;

 /**
 * Starts or resumes playback. If playback had previously been paused,
 * playback will continue from where it was paused. If playback had
 * been stopped, or never started before, playback will start at the
 * beginning.
 *
 * @throws IllegalStateException if it is called in an invalid state
 */
 public void start() throws IllegalStateException {
 stayAwake(true);
 _start();
 }

 private native void _start() throws IllegalStateException;

 /**
 * Stops playback after playback has been stopped or paused.
 *
 * @throws IllegalStateException if the internal player engine has not been
 * initialized.
 */
 public void stop() throws IllegalStateException {
 stayAwake(false);
 _stop();
 }

 private native void _stop() throws IllegalStateException;

 /**
 * Pauses playback. Call start() to resume.
 *
 * @throws IllegalStateException if the internal player engine has not been
 * initialized.
 */
 public void pause() throws IllegalStateException {
 stayAwake(false);
 _pause();
 }

 private native void _pause() throws IllegalStateException;

 /**
 * Set the low-level power management behavior for this MediaPlayer. This
 * can be used when the MediaPlayer is not playing through a SurfaceHolder
 * set with {@link #setDisplay(SurfaceHolder)} and thus can use the
 * high-level {@link #setScreenOnWhilePlaying(boolean)} feature.
 *
 * This function has the MediaPlayer access the low-level power manager
 * service to control the device's power usage while playing is occurring.
 * The parameter is a combination of {@link android.os.PowerManager} wake flags.
 * Use of this method requires {@link android.Manifest.permission#WAKE_LOCK}
 * permission.
 * By default, no attempt is made to keep the device awake during playback.
 *
 * @param context the Context to use
 * @param mode the power/wake mode to set
 * @see android.os.PowerManager
 */
 public void setWakeMode(Context context, int mode) {
 boolean washeld = false;
 if (mWakeLock != null) {
 if (mWakeLock.isHeld()) {
 washeld = true;
 mWakeLock.release();
 }
 mWakeLock = null;
 }

 PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
 mWakeLock = pm.newWakeLock(mode|PowerManager.ON_AFTER_RELEASE, MediaPlayer.class.getName());
 mWakeLock.setReferenceCounted(false);
 if (washeld) {
 mWakeLock.acquire();
 }
 }

 /**
 * Control whether we should use the attached SurfaceHolder to keep the
 * screen on while video playback is occurring. This is the preferred
 * method over {@link #setWakeMode} where possible, since it doesn't
 * require that the application have permission for low-level wake lock
 * access.
 *
 * @param screenOn Supply true to keep the screen on, false to allow it
 * to turn off.
 */
 public void setScreenOnWhilePlaying(boolean screenOn) {
 if (mScreenOnWhilePlaying != screenOn) {
 mScreenOnWhilePlaying = screenOn;
 updateSurfaceScreenOn();
 }
 }

 private void stayAwake(boolean awake) {
 if (mWakeLock != null) {
 if (awake && !mWakeLock.isHeld()) {
 mWakeLock.acquire();
 } else if (!awake && mWakeLock.isHeld()) {
 mWakeLock.release();
 }
 }
 mStayAwake = awake;
 updateSurfaceScreenOn();
 }

 private void updateSurfaceScreenOn() {
 if (mSurfaceHolder != null) {
 mSurfaceHolder.setKeepScreenOn(mScreenOnWhilePlaying && mStayAwake);
 }
 }

 /**
 * Returns the width of the video.
 *
 * @return the width of the video, or 0 if there is no video,
 * no display surface was set, or the width has not been determined
 * yet. The OnVideoSizeChangedListener can be registered via
 * {@link #setOnVideoSizeChangedListener(OnVideoSizeChangedListener)}
 * to provide a notification when the width is available.
 */
 public native int getVideoWidth();

 /**
 * Returns the height of the video.
 *
 * @return the height of the video, or 0 if there is no video,
 * no display surface was set, or the height has not been determined
 * yet. The OnVideoSizeChangedListener can be registered via
 * {@link #setOnVideoSizeChangedListener(OnVideoSizeChangedListener)}
 * to provide a notification when the height is available.
 */
 public native int getVideoHeight();

 /**
 * Checks whether the MediaPlayer is playing.
 *
 * @return true if currently playing, false otherwise
 */
 public native boolean isPlaying();

 /**
 * Seeks to specified time position.
 *
 * @param msec the offset in milliseconds from the start to seek to
 * @throws IllegalStateException if the internal player engine has not been
 * initialized
 */
 public native void seekTo(int msec) throws IllegalStateException;

 /**
 * Gets the current playback position.
 *
 * @return the current position in milliseconds
 */
 public native int getCurrentPosition();

 /**
 * Gets the duration of the file.
 *
 * @return the duration in milliseconds
 */
 public native int getDuration();

 /**
 * Releases resources associated with this MediaPlayer object.
 * It is considered good practice to call this method when you're
 * done using the MediaPlayer.
 */
 public void release() {
 stayAwake(false);
 updateSurfaceScreenOn();
 mOnPreparedListener = null;
 mOnBufferingUpdateListener = null;
 mOnCompletionListener = null;
 mOnSeekCompleteListener = null;
 mOnErrorListener = null;
 mOnInfoListener = null;
 mOnVideoSizeChangedListener = null;
 _release();
 }

 private native void _release();

 /**
 * Resets the MediaPlayer to its uninitialized state. After calling
 * this method, you will have to initialize it again by setting the
 * data source and calling prepare().
 */
 public void reset() {
 stayAwake(false);
 _reset();
 // make sure none of the listeners get called anymore
 mEventHandler.removeCallbacksAndMessages(null);
 }

 private native void _reset();

 /**
 * Sets the audio stream type for this MediaPlayer. See {@link AudioManager}
 * for a list of stream types.
 *
 * @param streamtype the audio stream type
 * @see android.media.AudioManager
 */
 public native void setAudioStreamType(int streamtype);

 /**
 * Sets the player to be looping or non-looping.
 *
 * @param looping whether to loop or not
 */
 public native void setLooping(boolean looping);

 /**
 * Checks whether the MediaPlayer is looping or non-looping.
 *
 * @return true if the MediaPlayer is currently looping, false otherwise
 */
 public native boolean isLooping();

 /**
 * Sets the volume on this player.
 * This API is recommended for balancing the output of audio streams
 * within an application. Unless you are writing an application to
 * control user settings, this API should be used in preference to
 * {@link AudioManager#setStreamVolume(int, int, int)} which sets the volume of ALL streams of
 * a particular type. Note that the passed volume values are raw scalars.
 * UI controls should be scaled logarithmically.
 *
 * @param leftVolume left volume scalar
 * @param rightVolume right volume scalar
 */
 public native void setVolume(float leftVolume, float rightVolume);

 /**
 * Currently not implemented, returns null.
 * @deprecated
 * @hide
 */
 public native Bitmap getFrameAt(int msec) throws IllegalStateException;

 private native final void native_setup(Object mediaplayer_this);
 private native final void native_finalize();
 @Override
 protected void finalize() { native_finalize(); }

 /* Do not change these values without updating their counterparts
 * in include/media/mediaplayer.h!
 */
 private static final int MEDIA_NOP = 0; // interface test message
 private static final int MEDIA_PREPARED = 1;
 private static final int MEDIA_PLAYBACK_COMPLETE = 2;
 private static final int MEDIA_BUFFERING_UPDATE = 3;
 private static final int MEDIA_SEEK_COMPLETE = 4;
 private static final int MEDIA_SET_VIDEO_SIZE = 5;
 private static final int MEDIA_ERROR = 100;
 private static final int MEDIA_INFO = 200;

 private class EventHandler extends Handler
 {
 private MediaPlayer mMediaPlayer;

 public EventHandler(MediaPlayer mp, Looper looper) {
 super(looper);
 mMediaPlayer = mp;
 }

 @Override
 public void handleMessage(Message msg) {
 if (mMediaPlayer.mNativeContext == 0) {
 Log.w(TAG, "mediaplayer went away with unhandled events");
 return;
 }
 switch(msg.what) {
 case MEDIA_PREPARED:
 if (mOnPreparedListener != null)
 mOnPreparedListener.onPrepared(mMediaPlayer);
 return;

 case MEDIA_PLAYBACK_COMPLETE:
 if (mOnCompletionListener != null)
 mOnCompletionListener.onCompletion(mMediaPlayer);
 stayAwake(false);
 return;

 case MEDIA_BUFFERING_UPDATE:
 if (mOnBufferingUpdateListener != null)
 mOnBufferingUpdateListener.onBufferingUpdate(mMediaPlayer, msg.arg1);
 return;

 case MEDIA_SEEK_COMPLETE:
 if (mOnSeekCompleteListener != null)
 mOnSeekCompleteListener.onSeekComplete(mMediaPlayer);
 return;

 case MEDIA_SET_VIDEO_SIZE:
 if (mOnVideoSizeChangedListener != null)
 mOnVideoSizeChangedListener.onVideoSizeChanged(mMediaPlayer, msg.arg1, msg.arg2);
 return;

 case MEDIA_ERROR:
 // For PV specific error values (msg.arg2) look in
 // opencore/pvmi/pvmf/include/pvmf_return_codes.h
 Log.e(TAG, "Error (" + msg.arg1 + "," + msg.arg2 + ")");
 boolean error_was_handled = false;
 if (mOnErrorListener != null) {
 error_was_handled = mOnErrorListener.onError(mMediaPlayer, msg.arg1, msg.arg2);
 }
 if (mOnCompletionListener != null && ! error_was_handled) {
 mOnCompletionListener.onCompletion(mMediaPlayer);
 }
 stayAwake(false);
 return;

 case MEDIA_INFO:
 // For PV specific code values (msg.arg2) look in
 // opencore/pvmi/pvmf/include/pvmf_return_codes.h
 Log.i(TAG, "Info (" + msg.arg1 + "," + msg.arg2 + ")");
 if (mOnInfoListener != null) {
 mOnInfoListener.onInfo(mMediaPlayer, msg.arg1, msg.arg2);
 }
 // No real default action so far.
 return;

 case MEDIA_NOP: // interface test message - ignore
 break;

 default:
 Log.e(TAG, "Unknown message type " + msg.what);
 return;
 }
 }
 }

 /**
 * Called from native code when an interesting event happens. This method
 * just uses the EventHandler system to post the event back to the main app thread.
 * We use a weak reference to the original MediaPlayer object so that the native
 * code is safe from the object disappearing from underneath it. (This is
 * the cookie passed to native_setup().)
 */
 private static void postEventFromNative(Object mediaplayer_ref,
 int what, int arg1, int arg2, Object obj)
 {
 MediaPlayer mp = (MediaPlayer)((WeakReference)mediaplayer_ref).get();
 if (mp == null) {
 return;
 }

 if (mp.mEventHandler != null) {
 Message m = mp.mEventHandler.obtainMessage(what, arg1, arg2, obj);
 mp.mEventHandler.sendMessage(m);
 }
 }

 /**
 * Interface definition for a callback to be invoked when the media
 * source is ready for playback.
 */
 public interface OnPreparedListener
 {
 /**
 * Called when the media file is ready for playback.
 *
 * @param mp the MediaPlayer that is ready for playback
 */
 void onPrepared(MediaPlayer mp);
 }

 /**
 * Register a callback to be invoked when the media source is ready
 * for playback.
 *
 * @param listener the callback that will be run
 */
 public void setOnPreparedListener(OnPreparedListener listener)
 {
 mOnPreparedListener = listener;
 }

 private OnPreparedListener mOnPreparedListener;

 /**
 * Interface definition for a callback to be invoked when playback of
 * a media source has completed.
 */
 public interface OnCompletionListener
 {
 /**
 * Called when the end of a media source is reached during playback.
 *
 * @param mp the MediaPlayer that reached the end of the file
 */
 void onCompletion(MediaPlayer mp);
 }

 /**
 * Register a callback to be invoked when the end of a media source
 * has been reached during playback.
 *
 * @param listener the callback that will be run
 */
 public void setOnCompletionListener(OnCompletionListener listener)
 {
 mOnCompletionListener = listener;
 }

 private OnCompletionListener mOnCompletionListener;

 /**
 * Interface definition of a callback to be invoked indicating buffering
 * status of a media resource being streamed over the network.
 */
 public interface OnBufferingUpdateListener
 {
 /**
 * Called to update status in buffering a media stream.
 *
 * @param mp the MediaPlayer the update pertains to
 * @param percent the percentage (0-100) of the buffer
 * that has been filled thus far
 */
 void onBufferingUpdate(MediaPlayer mp, int percent);
 }

 /**
 * Register a callback to be invoked when the status of a network
 * stream's buffer has changed.
 *
 * @param listener the callback that will be run.
 */
 public void setOnBufferingUpdateListener(OnBufferingUpdateListener listener)
 {
 mOnBufferingUpdateListener = listener;
 }

 private OnBufferingUpdateListener mOnBufferingUpdateListener;

 /**
 * Interface definition of a callback to be invoked indicating
 * the completion of a seek operation.
 */
 public interface OnSeekCompleteListener
 {
 /**
 * Called to indicate the completion of a seek operation.
 *
 * @param mp the MediaPlayer that issued the seek operation
 */
 public void onSeekComplete(MediaPlayer mp);
 }

 /**
 * Register a callback to be invoked when a seek operation has been
 * completed.
 *
 * @param listener the callback that will be run
 */
 public void setOnSeekCompleteListener(OnSeekCompleteListener listener)
 {
 mOnSeekCompleteListener = listener;
 }

 private OnSeekCompleteListener mOnSeekCompleteListener;

 /**
 * Interface definition of a callback to be invoked when the
 * video size is first known or updated
 */
 public interface OnVideoSizeChangedListener
 {
 /**
 * Called to indicate the video size
 *
 * @param mp the MediaPlayer associated with this callback
 * @param width the width of the video
 * @param height the height of the video
 */
 public void onVideoSizeChanged(MediaPlayer mp, int width, int height);
 }

 /**
 * Register a callback to be invoked when the video size is
 * known or updated.
 *
 * @param listener the callback that will be run
 */
 public void setOnVideoSizeChangedListener(OnVideoSizeChangedListener listener)
 {
 mOnVideoSizeChangedListener = listener;
 }

 private OnVideoSizeChangedListener mOnVideoSizeChangedListener;

 /* Do not change these values without updating their counterparts
 * in include/media/mediaplayer.h!
 */
 /** Unspecified media player error.
 * @see android.media.MediaPlayer.OnErrorListener
 */
 public static final int MEDIA_ERROR_UNKNOWN = 1;

 /** Media server died. In this case, the application must release the
 * MediaPlayer object and instantiate a new one.
 * @see android.media.MediaPlayer.OnErrorListener
 */
 public static final int MEDIA_ERROR_SERVER_DIED = 100;

 /** The video is streamed and its container is not valid for progressive
 * playback i.e the video's index (e.g moov atom) is not at the start of the
 * file.
 * @see android.media.MediaPlayer.OnErrorListener
 */
 public static final int MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK = 200;

 /**
 * Interface definition of a callback to be invoked when there
 * has been an error during an asynchronous operation (other errors
 * will throw exceptions at method call time).
 */
 public interface OnErrorListener
 {
 /**
 * Called to indicate an error.
 *
 * @param mp the MediaPlayer the error pertains to
 * @param what the type of error that has occurred:
 * <ul>
 * <li>{@link #MEDIA_ERROR_UNKNOWN}
 * <li>{@link #MEDIA_ERROR_SERVER_DIED}
 * </ul>
 * @param extra an extra code, specific to the error. Typically
 * implementation dependant.
 * @return True if the method handled the error, false if it didn't.
 * Returning false, or not having an OnErrorListener at all, will
 * cause the OnCompletionListener to be called.
 */
 boolean onError(MediaPlayer mp, int what, int extra);
 }

 /**
 * Register a callback to be invoked when an error has happened
 * during an asynchronous operation.
 *
 * @param listener the callback that will be run
 */
 public void setOnErrorListener(OnErrorListener listener)
 {
 mOnErrorListener = listener;
 }

 private OnErrorListener mOnErrorListener;

 /* Do not change these values without updating their counterparts
 * in include/media/mediaplayer.h!
 */
 /** Unspecified media player info.
 * @see android.media.MediaPlayer.OnInfoListener
 */
 public static final int MEDIA_INFO_UNKNOWN = 1;

 /** The video is too complex for the decoder: it can't decode frames fast
 * enough. Possibly only the audio plays fine at this stage.
 * @see android.media.MediaPlayer.OnInfoListener
 */
 public static final int MEDIA_INFO_VIDEO_TRACK_LAGGING = 700;

 /** Bad interleaving means that a media has been improperly interleaved or
 * not interleaved at all, e.g has all the video samples first then all the
 * audio ones. Video is playing but a lot of disk seeks may be happening.
 * @see android.media.MediaPlayer.OnInfoListener
 */
 public static final int MEDIA_INFO_BAD_INTERLEAVING = 800;

 /** The media cannot be seeked (e.g live stream)
 * @see android.media.MediaPlayer.OnInfoListener
 */
 public static final int MEDIA_INFO_NOT_SEEKABLE = 801;

 /**
 * Interface definition of a callback to be invoked to communicate some
 * info and/or warning about the media or its playback.
 */
 public interface OnInfoListener
 {
 /**
 * Called to indicate an info or a warning.
 *
 * @param mp the MediaPlayer the info pertains to.
 * @param what the type of info or warning.
 * <ul>
 * <li>{@link #MEDIA_INFO_UNKNOWN}
 * <li>{@link #MEDIA_INFO_VIDEO_TRACK_LAGGING}
 * <li>{@link #MEDIA_INFO_BAD_INTERLEAVING}
 * <li>{@link #MEDIA_INFO_NOT_SEEKABLE}
 * </ul>
 * @param extra an extra code, specific to the info. Typically
 * implementation dependant.
 * @return True if the method handled the info, false if it didn't.
 * Returning false, or not having an OnErrorListener at all, will
 * cause the info to be discarded.
 */
 boolean onInfo(MediaPlayer mp, int what, int extra);
 }

 /**
 * Register a callback to be invoked when an info/warning is available.
 *
 * @param listener the callback that will be run
 */
 public void setOnInfoListener(OnInfoListener listener)
 {
 mOnInfoListener = listener;
 }

 private OnInfoListener mOnInfoListener;
}

저작자표시

Posted by 빈솔B

,

MediaController.java Source

Android/Android Platform 2010. 3. 22. 12:05

/*
* Copyright (C) 2006 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 android.widget;

import android.content.Context;
import android.graphics.PixelFormat;
import android.media.AudioManager;
import android.os.Handler;
import android.os.Message;
import android.util.AttributeSet;
import android.util.Log;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.WindowManager;
import android.widget.SeekBar.OnSeekBarChangeListener;

import com.android.internal.policy.PolicyManager;

import java.util.Formatter;
import java.util.Locale;

/**
* A view containing controls for a MediaPlayer. Typically contains the
* buttons like "Play/Pause", "Rewind", "Fast Forward" and a progress
* slider. It takes care of synchronizing the controls with the state
* of the MediaPlayer.
* 
* The way to use this class is to instantiate it programatically.
* The MediaController will create a default set of controls
* and put them in a window floating above your application. Specifically,
* the controls will float above the view specified with setAnchorView().
* The window will disappear if left idle for three seconds and reappear
* when the user touches the anchor view.
* 
* Functions like show() and hide() have no effect when MediaController
* is created in an xml layout.
*
* MediaController will hide and
* show the buttons according to these rules:
* <ul>
* <li> The "previous" and "next" buttons are hidden until setPrevNextListeners()
* has been called
* <li> The "previous" and "next" buttons are visible but disabled if
* setPrevNextListeners() was called with null listeners
* <li> The "rewind" and "fastforward" buttons are shown unless requested
* otherwise by using the MediaController(Context, boolean) constructor
* with the boolean set to false
* </ul>
*/
public class MediaController extends FrameLayout {

 private MediaPlayerControl mPlayer;
 private Context mContext;
 private View mAnchor;
 private View mRoot;
 private WindowManager mWindowManager;
 private Window mWindow;
 private View mDecor;
 private ProgressBar mProgress;
 private TextView mEndTime, mCurrentTime;
 private boolean mShowing;
 private boolean mDragging;
 private static final int sDefaultTimeout = 3000;
 private static final int FADE_OUT = 1;
 private static final int SHOW_PROGRESS = 2;
 private boolean mUseFastForward;
 private boolean mFromXml;
 private boolean mListenersSet;
 private View.OnClickListener mNextListener, mPrevListener;
 StringBuilder mFormatBuilder;
 Formatter mFormatter;
 private ImageButton mPauseButton;
 private ImageButton mFfwdButton;
 private ImageButton mRewButton;
 private ImageButton mNextButton;
 private ImageButton mPrevButton;

 public MediaController(Context context, AttributeSet attrs) {
 super(context, attrs);
 mRoot = this;
 mContext = context;
 mUseFastForward = true;
 mFromXml = true;
 }

 @Override
 public void onFinishInflate() {
 if (mRoot != null)
 initControllerView(mRoot);
 }

 public MediaController(Context context, boolean useFastForward) {
 super(context);
 mContext = context;
 mUseFastForward = useFastForward;
 initFloatingWindow();
 }

 public MediaController(Context context) {
 super(context);
 mContext = context;
 mUseFastForward = true;
 initFloatingWindow();
 }

 private void initFloatingWindow() {
 mWindowManager = (WindowManager)mContext.getSystemService("window");
 mWindow = PolicyManager.makeNewWindow(mContext);
 mWindow.setWindowManager(mWindowManager, null, null);
 mWindow.requestFeature(Window.FEATURE_NO_TITLE);
 mDecor = mWindow.getDecorView();
 mDecor.setOnTouchListener(mTouchListener);
 mWindow.setContentView(this);
 mWindow.setBackgroundDrawableResource(android.R.color.transparent);

 // While the media controller is up, the volume control keys should
 // affect the media stream type
 mWindow.setVolumeControlStream(AudioManager.STREAM_MUSIC);

 setFocusable(true);
 setFocusableInTouchMode(true);
 setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
 requestFocus();
 }

 private OnTouchListener mTouchListener = new OnTouchListener() {
 public boolean onTouch(View v, MotionEvent event) {
 if (event.getAction() == MotionEvent.ACTION_DOWN) {
 if (mShowing) {
 hide();
 }
 }
 return false;
 }
 };

 public void setMediaPlayer(MediaPlayerControl player) {
 mPlayer = player;
 updatePausePlay();
 }

 /**
 * Set the view that acts as the anchor for the control view.
 * This can for example be a VideoView, or your Activity's main view.
 * @param view The view to which to anchor the controller when it is visible.
 */
 public void setAnchorView(View view) {
 mAnchor = view;

 FrameLayout.LayoutParams frameParams = new FrameLayout.LayoutParams(
 ViewGroup.LayoutParams.FILL_PARENT,
 ViewGroup.LayoutParams.FILL_PARENT
 );

 removeAllViews();
 View v = makeControllerView();
 addView(v, frameParams);
 }

 /**
 * Create the view that holds the widgets that control playback.
 * Derived classes can override this to create their own.
 * @return The controller view.
 * @hide This doesn't work as advertised
 */
 protected View makeControllerView() {
 LayoutInflater inflate = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
 mRoot = inflate.inflate(com.android.internal.R.layout.media_controller, null);

 initControllerView(mRoot);

 return mRoot;
 }

 private void initControllerView(View v) {
 mPauseButton = (ImageButton) v.findViewById(com.android.internal.R.id.pause);
 if (mPauseButton != null) {
 mPauseButton.requestFocus();
 mPauseButton.setOnClickListener(mPauseListener);
 }

 mFfwdButton = (ImageButton) v.findViewById(com.android.internal.R.id.ffwd);
 if (mFfwdButton != null) {
 mFfwdButton.setOnClickListener(mFfwdListener);
 if (!mFromXml) {
 mFfwdButton.setVisibility(mUseFastForward ? View.VISIBLE : View.GONE);
 }
 }

 mRewButton = (ImageButton) v.findViewById(com.android.internal.R.id.rew);
 if (mRewButton != null) {
 mRewButton.setOnClickListener(mRewListener);
 if (!mFromXml) {
 mRewButton.setVisibility(mUseFastForward ? View.VISIBLE : View.GONE);
 }
 }

 // By default these are hidden. They will be enabled when setPrevNextListeners() is called
 mNextButton = (ImageButton) v.findViewById(com.android.internal.R.id.next);
 if (mNextButton != null && !mFromXml && !mListenersSet) {
 mNextButton.setVisibility(View.GONE);
 }
 mPrevButton = (ImageButton) v.findViewById(com.android.internal.R.id.prev);
 if (mPrevButton != null && !mFromXml && !mListenersSet) {
 mPrevButton.setVisibility(View.GONE);
 }

 mProgress = (ProgressBar) v.findViewById(com.android.internal.R.id.mediacontroller_progress);
 if (mProgress != null) {
 if (mProgress instanceof SeekBar) {
 SeekBar seeker = (SeekBar) mProgress;
 seeker.setOnSeekBarChangeListener(mSeekListener);
 }
 mProgress.setMax(1000);
 }

 mEndTime = (TextView) v.findViewById(com.android.internal.R.id.time);
 mCurrentTime = (TextView) v.findViewById(com.android.internal.R.id.time_current);
 mFormatBuilder = new StringBuilder();
 mFormatter = new Formatter(mFormatBuilder, Locale.getDefault());

 installPrevNextListeners();
 }

 /**
 * Show the controller on screen. It will go away
 * automatically after 3 seconds of inactivity.
 */
 public void show() {
 show(sDefaultTimeout);
 }

 /**
 * Show the controller on screen. It will go away
 * automatically after 'timeout' milliseconds of inactivity.
 * @param timeout The timeout in milliseconds. Use 0 to show
 * the controller until hide() is called.
 */
 public void show(int timeout) {

 if (!mShowing && mAnchor != null) {
 setProgress();

 int [] anchorpos = new int[2];
 mAnchor.getLocationOnScreen(anchorpos);

 WindowManager.LayoutParams p = new WindowManager.LayoutParams();
 p.gravity = Gravity.TOP;
 p.width = mAnchor.getWidth();
 p.height = LayoutParams.WRAP_CONTENT;
 p.x = 0;
 p.y = anchorpos[1] + mAnchor.getHeight() - p.height;
 p.format = PixelFormat.TRANSLUCENT;
 p.type = WindowManager.LayoutParams.TYPE_APPLICATION_PANEL;
 p.flags |= WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;
 p.token = null;
 p.windowAnimations = 0; // android.R.style.DropDownAnimationDown;
 mWindowManager.addView(mDecor, p);
 mShowing = true;
 }
 updatePausePlay();

 // cause the progress bar to be updated even if mShowing
 // was already true. This happens, for example, if we're
 // paused with the progress bar showing the user hits play.
 mHandler.sendEmptyMessage(SHOW_PROGRESS);

 Message msg = mHandler.obtainMessage(FADE_OUT);
 if (timeout != 0) {
 mHandler.removeMessages(FADE_OUT);
 mHandler.sendMessageDelayed(msg, timeout);
 }
 }

 public boolean isShowing() {
 return mShowing;
 }

 /**
 * Remove the controller from the screen.
 */
 public void hide() {
 if (mAnchor == null)
 return;

 if (mShowing) {
 try {
 mHandler.removeMessages(SHOW_PROGRESS);
 mWindowManager.removeView(mDecor);
 } catch (IllegalArgumentException ex) {
 Log.w("MediaController", "already removed");
 }
 mShowing = false;
 }
 }

 private Handler mHandler = new Handler() {
 @Override
 public void handleMessage(Message msg) {
 int pos;
 switch (msg.what) {
 case FADE_OUT:
 hide();
 break;
 case SHOW_PROGRESS:
 pos = setProgress();
 if (!mDragging && mShowing && mPlayer.isPlaying()) {
 msg = obtainMessage(SHOW_PROGRESS);
 sendMessageDelayed(msg, 1000 - (pos % 1000));
 }
 break;
 }
 }
 };

 private String stringForTime(int timeMs) {
 int totalSeconds = timeMs / 1000;

 int seconds = totalSeconds % 60;
 int minutes = (totalSeconds / 60) % 60;
 int hours = totalSeconds / 3600;

 mFormatBuilder.setLength(0);
 if (hours > 0) {
 return mFormatter.format("%d:%02d:%02d", hours, minutes, seconds).toString();
 } else {
 return mFormatter.format("%02d:%02d", minutes, seconds).toString();
 }
 }

 private int setProgress() {
 if (mPlayer == null || mDragging) {
 return 0;
 }
 int position = mPlayer.getCurrentPosition();
 int duration = mPlayer.getDuration();
 if (mProgress != null) {
 if (duration > 0) {
 // use long to avoid overflow
 long pos = 1000L * position / duration;
 mProgress.setProgress( (int) pos);
 }
 int percent = mPlayer.getBufferPercentage();
 mProgress.setSecondaryProgress(percent * 10);
 }

 if (mEndTime != null)
 mEndTime.setText(stringForTime(duration));
 if (mCurrentTime != null)
 mCurrentTime.setText(stringForTime(position));

 return position;
 }

 @Override
 public boolean onTouchEvent(MotionEvent event) {
 show(sDefaultTimeout);
 return true;
 }

 @Override
 public boolean onTrackballEvent(MotionEvent ev) {
 show(sDefaultTimeout);
 return false;
 }

 @Override
 public boolean dispatchKeyEvent(KeyEvent event) {
 int keyCode = event.getKeyCode();
 if (event.getRepeatCount() == 0 && event.isDown() && (
 keyCode == KeyEvent.KEYCODE_HEADSETHOOK ||
 keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE ||
 keyCode == KeyEvent.KEYCODE_SPACE)) {
 doPauseResume();
 show(sDefaultTimeout);
 return true;
 } else if (keyCode == KeyEvent.KEYCODE_MEDIA_STOP) {
 if (mPlayer.isPlaying()) {
 mPlayer.pause();
 updatePausePlay();
 }
 return true;
 } else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN ||
 keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
 // don't show the controls for volume adjustment
 return super.dispatchKeyEvent(event);
 } else if (keyCode == KeyEvent.KEYCODE_BACK || keyCode == KeyEvent.KEYCODE_MENU) {
 hide();

 return true;
 } else {
 show(sDefaultTimeout);
 }
 return super.dispatchKeyEvent(event);
 }

 private View.OnClickListener mPauseListener = new View.OnClickListener() {
 public void onClick(View v) {
 doPauseResume();
 show(sDefaultTimeout);
 }
 };

 private void updatePausePlay() {
 if (mRoot == null)
 return;

 ImageButton button = (ImageButton) mRoot.findViewById(com.android.internal.R.id.pause);
 if (button == null)
 return;

 if (mPlayer.isPlaying()) {
 button.setImageResource(com.android.internal.R.drawable.ic_media_pause);
 } else {
 button.setImageResource(com.android.internal.R.drawable.ic_media_play);
 }
 }

 private void doPauseResume() {
 if (mPlayer.isPlaying()) {
 mPlayer.pause();
 } else {
 mPlayer.start();
 }
 updatePausePlay();
 }

 // There are two scenarios that can trigger the seekbar listener to trigger:
 //
 // The first is the user using the touchpad to adjust the posititon of the
 // seekbar's thumb. In this case onStartTrackingTouch is called followed by
 // a number of onProgressChanged notifications, concluded by onStopTrackingTouch.
 // We're setting the field "mDragging" to true for the duration of the dragging
 // session to avoid jumps in the position in case of ongoing playback.
 //
 // The second scenario involves the user operating the scroll ball, in this
 // case there WON'T BE onStartTrackingTouch/onStopTrackingTouch notifications,
 // we will simply apply the updated position without suspending regular updates.
 private OnSeekBarChangeListener mSeekListener = new OnSeekBarChangeListener() {
 public void onStartTrackingTouch(SeekBar bar) {
 show(3600000);

 mDragging = true;

 // By removing these pending progress messages we make sure
 // that a) we won't update the progress while the user adjusts
 // the seekbar and b) once the user is done dragging the thumb
 // we will post one of these messages to the queue again and
 // this ensures that there will be exactly one message queued up.
 mHandler.removeMessages(SHOW_PROGRESS);
 }

 public void onProgressChanged(SeekBar bar, int progress, boolean fromuser) {
 if (!fromuser) {
 // We're not interested in programmatically generated changes to
 // the progress bar's position.
 return;
 }

 long duration = mPlayer.getDuration();
 long newposition = (duration * progress) / 1000L;
 mPlayer.seekTo( (int) newposition);
 if (mCurrentTime != null)
 mCurrentTime.setText(stringForTime( (int) newposition));
 }

 public void onStopTrackingTouch(SeekBar bar) {
 mDragging = false;
 setProgress();
 updatePausePlay();
 show(sDefaultTimeout);

 // Ensure that progress is properly updated in the future,
 // the call to show() does not guarantee this because it is a
 // no-op if we are already showing.
 mHandler.sendEmptyMessage(SHOW_PROGRESS);
 }
 };

 @Override
 public void setEnabled(boolean enabled) {
 if (mPauseButton != null) {
 mPauseButton.setEnabled(enabled);
 }
 if (mFfwdButton != null) {
 mFfwdButton.setEnabled(enabled);
 }
 if (mRewButton != null) {
 mRewButton.setEnabled(enabled);
 }
 if (mNextButton != null) {
 mNextButton.setEnabled(enabled && mNextListener != null);
 }
 if (mPrevButton != null) {
 mPrevButton.setEnabled(enabled && mPrevListener != null);
 }
 if (mProgress != null) {
 mProgress.setEnabled(enabled);
 }

 super.setEnabled(enabled);
 }

 private View.OnClickListener mRewListener = new View.OnClickListener() {
 public void onClick(View v) {
 int pos = mPlayer.getCurrentPosition();
 pos -= 5000; // milliseconds
 mPlayer.seekTo(pos);
 setProgress();

 show(sDefaultTimeout);
 }
 };

 private View.OnClickListener mFfwdListener = new View.OnClickListener() {
 public void onClick(View v) {
 int pos = mPlayer.getCurrentPosition();
 pos += 15000; // milliseconds
 mPlayer.seekTo(pos);
 setProgress();

 show(sDefaultTimeout);
 }
 };

 private void installPrevNextListeners() {
 if (mNextButton != null) {
 mNextButton.setOnClickListener(mNextListener);
 mNextButton.setEnabled(mNextListener != null);
 }

 if (mPrevButton != null) {
 mPrevButton.setOnClickListener(mPrevListener);
 mPrevButton.setEnabled(mPrevListener != null);
 }
 }

 public void setPrevNextListeners(View.OnClickListener next, View.OnClickListener prev) {
 mNextListener = next;
 mPrevListener = prev;
 mListenersSet = true;

 if (mRoot != null) {
 installPrevNextListeners();

 if (mNextButton != null && !mFromXml) {
 mNextButton.setVisibility(View.VISIBLE);
 }
 if (mPrevButton != null && !mFromXml) {
 mPrevButton.setVisibility(View.VISIBLE);
 }
 }
 }

 public interface MediaPlayerControl {
 void start();
 void pause();
 int getDuration();
 int getCurrentPosition();
 void seekTo(int pos);
 boolean isPlaying();
 int getBufferPercentage();
 };
}

저작자표시

Posted by 빈솔B

,

Gallery.java Source

Android/Android Platform 2010. 3. 22. 12:04

/*
* Copyright (C) 2007 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 android.widget;

import com.android.internal.R;

import android.annotation.Widget;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.util.Config;
import android.util.Log;
import android.view.GestureDetector;
import android.view.Gravity;
import android.view.HapticFeedbackConstants;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.view.SoundEffectConstants;
import android.view.ContextMenu.ContextMenuInfo;
import android.view.animation.Transformation;
import android.widget.AbsSpinner;
import android.widget.Scroller;

/**
* A view that shows items in a center-locked, horizontally scrolling list.
* 
* The default values for the Gallery assume you will be using
* {@link android.R.styleable#Theme_galleryItemBackground} as the background for
* each View given to the Gallery from the Adapter. If you are not doing this,
* you may need to adjust some Gallery properties, such as the spacing.
* 
* Views given to the Gallery should use {@link Gallery.LayoutParams} as their
* layout parameters type.
*
* @attr ref android.R.styleable#Gallery_animationDuration
* @attr ref android.R.styleable#Gallery_spacing
* @attr ref android.R.styleable#Gallery_gravity
*/
@Widget
public class Gallery extends AbsSpinner implements GestureDetector.OnGestureListener {

 private static final String TAG = "Gallery";

 private static final boolean localLOGV = Config.LOGV;

 /**
 * Duration in milliseconds from the start of a scroll during which we're
 * unsure whether the user is scrolling or flinging.
 */
 private static final int SCROLL_TO_FLING_UNCERTAINTY_TIMEOUT = 250;

 /**
 * Horizontal spacing between items.
 */
 private int mSpacing = 0;

 /**
 * How long the transition animation should run when a child view changes
 * position, measured in milliseconds.
 */
 private int mAnimationDuration = 400;

 /**
 * The alpha of items that are not selected.
 */
 private float mUnselectedAlpha;

 /**
 * Left most edge of a child seen so far during layout.
 */
 private int mLeftMost;

 /**
 * Right most edge of a child seen so far during layout.
 */
 private int mRightMost;

 private int mGravity;

 /**
 * Helper for detecting touch gestures.
 */
 private GestureDetector mGestureDetector;

 /**
 * The position of the item that received the user's down touch.
 */
 private int mDownTouchPosition;

 /**
 * The view of the item that received the user's down touch.
 */
 private View mDownTouchView;

 /**
 * Executes the delta scrolls from a fling or scroll movement.
 */
 private FlingRunnable mFlingRunnable = new FlingRunnable();

 /**
 * Sets mSuppressSelectionChanged = false. This is used to set it to false
 * in the future. It will also trigger a selection changed.
 */
 private Runnable mDisableSuppressSelectionChangedRunnable = new Runnable() {
 public void run() {
 mSuppressSelectionChanged = false;
 selectionChanged();
 }
 };

 /**
 * When fling runnable runs, it resets this to false. Any method along the
 * path until the end of its run() can set this to true to abort any
 * remaining fling. For example, if we've reached either the leftmost or
 * rightmost item, we will set this to true.
 */
 private boolean mShouldStopFling;

 /**
 * The currently selected item's child.
 */
 private View mSelectedChild;

 /**
 * Whether to continuously callback on the item selected listener during a
 * fling.
 */
 private boolean mShouldCallbackDuringFling = true;

 /**
 * Whether to callback when an item that is not selected is clicked.
 */
 private boolean mShouldCallbackOnUnselectedItemClick = true;

 /**
 * If true, do not callback to item selected listener.
 */
 private boolean mSuppressSelectionChanged;

 /**
 * If true, we have received the "invoke" (center or enter buttons) key
 * down. This is checked before we action on the "invoke" key up, and is
 * subsequently cleared.
 */
 private boolean mReceivedInvokeKeyDown;

 private AdapterContextMenuInfo mContextMenuInfo;

 /**
 * If true, this onScroll is the first for this user's drag (remember, a
 * drag sends many onScrolls).
 */
 private boolean mIsFirstScroll;

 public Gallery(Context context) {
 this(context, null);
 }

 public Gallery(Context context, AttributeSet attrs) {
 this(context, attrs, R.attr.galleryStyle);
 }

 public Gallery(Context context, AttributeSet attrs, int defStyle) {
 super(context, attrs, defStyle);

 mGestureDetector = new GestureDetector(context, this);
 mGestureDetector.setIsLongpressEnabled(true);

 TypedArray a = context.obtainStyledAttributes(
 attrs, com.android.internal.R.styleable.Gallery, defStyle, 0);

 int index = a.getInt(com.android.internal.R.styleable.Gallery_gravity, -1);
 if (index >= 0) {
 setGravity(index);
 }

 int animationDuration =
 a.getInt(com.android.internal.R.styleable.Gallery_animationDuration, -1);
 if (animationDuration > 0) {
 setAnimationDuration(animationDuration);
 }

 int spacing =
 a.getDimensionPixelOffset(com.android.internal.R.styleable.Gallery_spacing, 0);
 setSpacing(spacing);

 float unselectedAlpha = a.getFloat(
 com.android.internal.R.styleable.Gallery_unselectedAlpha, 0.5f);
 setUnselectedAlpha(unselectedAlpha);

 a.recycle();

 // We draw the selected item last (because otherwise the item to the
 // right overlaps it)
 mGroupFlags |= FLAG_USE_CHILD_DRAWING_ORDER;

 mGroupFlags |= FLAG_SUPPORT_STATIC_TRANSFORMATIONS;
 }

 /**
 * Whether or not to callback on any {@link #getOnItemSelectedListener()}
 * while the items are being flinged. If false, only the final selected item
 * will cause the callback. If true, all items between the first and the
 * final will cause callbacks.
 *
 * @param shouldCallback Whether or not to callback on the listener while
 * the items are being flinged.
 */
 public void setCallbackDuringFling(boolean shouldCallback) {
 mShouldCallbackDuringFling = shouldCallback;
 }

 /**
 * Whether or not to callback when an item that is not selected is clicked.
 * If false, the item will become selected (and re-centered). If true, the
 * {@link #getOnItemClickListener()} will get the callback.
 *
 * @param shouldCallback Whether or not to callback on the listener when a
 * item that is not selected is clicked.
 * @hide
 */
 public void setCallbackOnUnselectedItemClick(boolean shouldCallback) {
 mShouldCallbackOnUnselectedItemClick = shouldCallback;
 }

 /**
 * Sets how long the transition animation should run when a child view
 * changes position. Only relevant if animation is turned on.
 *
 * @param animationDurationMillis The duration of the transition, in
 * milliseconds.
 *
 * @attr ref android.R.styleable#Gallery_animationDuration
 */
 public void setAnimationDuration(int animationDurationMillis) {
 mAnimationDuration = animationDurationMillis;
 }

 /**
 * Sets the spacing between items in a Gallery
 *
 * @param spacing The spacing in pixels between items in the Gallery
 *
 * @attr ref android.R.styleable#Gallery_spacing
 */
 public void setSpacing(int spacing) {
 mSpacing = spacing;
 }

 /**
 * Sets the alpha of items that are not selected in the Gallery.
 *
 * @param unselectedAlpha the alpha for the items that are not selected.
 *
 * @attr ref android.R.styleable#Gallery_unselectedAlpha
 */
 public void setUnselectedAlpha(float unselectedAlpha) {
 mUnselectedAlpha = unselectedAlpha;
 }

 @Override
 protected boolean getChildStaticTransformation(View child, Transformation t) {

 t.clear();
 t.setAlpha(child == mSelectedChild ? 1.0f : mUnselectedAlpha);

 return true;
 }

 @Override
 protected int computeHorizontalScrollExtent() {
 // Only 1 item is considered to be selected
 return 1;
 }

 @Override
 protected int computeHorizontalScrollOffset() {
 // Current scroll position is the same as the selected position
 return mSelectedPosition;
 }

 @Override
 protected int computeHorizontalScrollRange() {
 // Scroll range is the same as the item count
 return mItemCount;
 }

 @Override
 protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
 return p instanceof LayoutParams;
 }

 @Override
 protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
 return new LayoutParams(p);
 }

 @Override
 public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
 return new LayoutParams(getContext(), attrs);
 }

 @Override
 protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
 /*
 * Gallery expects Gallery.LayoutParams.
 */
 return new Gallery.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
 ViewGroup.LayoutParams.WRAP_CONTENT);
 }

 @Override
 protected void onLayout(boolean changed, int l, int t, int r, int b) {
 super.onLayout(changed, l, t, r, b);

 /*
 * Remember that we are in layout to prevent more layout request from
 * being generated.
 */
 mInLayout = true;
 layout(0, false);
 mInLayout = false;
 }

 @Override
 int getChildHeight(View child) {
 return child.getMeasuredHeight();
 }

 /**
 * Tracks a motion scroll. In reality, this is used to do just about any
 * movement to items (touch scroll, arrow-key scroll, set an item as selected).
 *
 * @param deltaX Change in X from the previous event.
 */
 void trackMotionScroll(int deltaX) {

 if (getChildCount() == 0) {
 return;
 }

 boolean toLeft = deltaX < 0;

 int limitedDeltaX = getLimitedMotionScrollAmount(toLeft, deltaX);
 if (limitedDeltaX != deltaX) {
 // The above call returned a limited amount, so stop any scrolls/flings
 mFlingRunnable.endFling(false);
 onFinishedMovement();
 }

 offsetChildrenLeftAndRight(limitedDeltaX);

 detachOffScreenChildren(toLeft);

 if (toLeft) {
 // If moved left, there will be empty space on the right
 fillToGalleryRight();
 } else {
 // Similarly, empty space on the left
 fillToGalleryLeft();
 }

 // Clear unused views
 mRecycler.clear();

 setSelectionToCenterChild();

 invalidate();
 }

 int getLimitedMotionScrollAmount(boolean motionToLeft, int deltaX) {
 int extremeItemPosition = motionToLeft ? mItemCount - 1 : 0;
 View extremeChild = getChildAt(extremeItemPosition - mFirstPosition);

 if (extremeChild == null) {
 return deltaX;
 }

 int extremeChildCenter = getCenterOfView(extremeChild);
 int galleryCenter = getCenterOfGallery();

 if (motionToLeft) {
 if (extremeChildCenter <= galleryCenter) {

 // The extreme child is past his boundary point!
 return 0;
 }
 } else {
 if (extremeChildCenter >= galleryCenter) {

 // The extreme child is past his boundary point!
 return 0;
 }
 }

 int centerDifference = galleryCenter - extremeChildCenter;

 return motionToLeft
 ? Math.max(centerDifference, deltaX)
 : Math.min(centerDifference, deltaX);
 }

 /**
 * Offset the horizontal location of all children of this view by the
 * specified number of pixels.
 *
 * @param offset the number of pixels to offset
 */
 private void offsetChildrenLeftAndRight(int offset) {
 for (int i = getChildCount() - 1; i >= 0; i--) {
 getChildAt(i).offsetLeftAndRight(offset);
 }
 }

 /**
 * @return The center of this Gallery.
 */
 private int getCenterOfGallery() {
 return (getWidth() - mPaddingLeft - mPaddingRight) / 2 + mPaddingLeft;
 }

 /**
 * @return The center of the given view.
 */
 private static int getCenterOfView(View view) {
 return view.getLeft() + view.getWidth() / 2;
 }

 /**
 * Detaches children that are off the screen (i.e.: Gallery bounds).
 *
 * @param toLeft Whether to detach children to the left of the Gallery, or
 * to the right.
 */
 private void detachOffScreenChildren(boolean toLeft) {
 int numChildren = getChildCount();
 int firstPosition = mFirstPosition;
 int start = 0;
 int count = 0;

 if (toLeft) {
 final int galleryLeft = mPaddingLeft;
 for (int i = 0; i < numChildren; i++) {
 final View child = getChildAt(i);
 if (child.getRight() >= galleryLeft) {
 break;
 } else {
 count++;
 mRecycler.put(firstPosition + i, child);
 }
 }
 } else {
 final int galleryRight = getWidth() - mPaddingRight;
 for (int i = numChildren - 1; i >= 0; i--) {
 final View child = getChildAt(i);
 if (child.getLeft() <= galleryRight) {
 break;
 } else {
 start = i;
 count++;
 mRecycler.put(firstPosition + i, child);
 }
 }
 }

 detachViewsFromParent(start, count);

 if (toLeft) {
 mFirstPosition += count;
 }
 }

 /**
 * Scrolls the items so that the selected item is in its 'slot' (its center
 * is the gallery's center).
 */
 private void scrollIntoSlots() {

 if (getChildCount() == 0 || mSelectedChild == null) return;

 int selectedCenter = getCenterOfView(mSelectedChild);
 int targetCenter = getCenterOfGallery();

 int scrollAmount = targetCenter - selectedCenter;
 if (scrollAmount != 0) {
 mFlingRunnable.startUsingDistance(scrollAmount);
 } else {
 onFinishedMovement();
 }
 }

 private void onFinishedMovement() {
 if (mSuppressSelectionChanged) {
 mSuppressSelectionChanged = false;

 // We haven't been callbacking during the fling, so do it now
 super.selectionChanged();
 }
 }

 @Override
 void selectionChanged() {
 if (!mSuppressSelectionChanged) {
 super.selectionChanged();
 }
 }

 /**
 * Looks for the child that is closest to the center and sets it as the
 * selected child.
 */
 private void setSelectionToCenterChild() {

 View selView = mSelectedChild;
 if (mSelectedChild == null) return;

 int galleryCenter = getCenterOfGallery();

 if (selView != null) {

 // Common case where the current selected position is correct
 if (selView.getLeft() <= galleryCenter && selView.getRight() >= galleryCenter) {
 return;
 }
 }

 // TODO better search
 int closestEdgeDistance = Integer.MAX_VALUE;
 int newSelectedChildIndex = 0;
 for (int i = getChildCount() - 1; i >= 0; i--) {

 View child = getChildAt(i);

 if (child.getLeft() <= galleryCenter && child.getRight() >= galleryCenter) {
 // This child is in the center
 newSelectedChildIndex = i;
 break;
 }

 int childClosestEdgeDistance = Math.min(Math.abs(child.getLeft() - galleryCenter),
 Math.abs(child.getRight() - galleryCenter));
 if (childClosestEdgeDistance < closestEdgeDistance) {
 closestEdgeDistance = childClosestEdgeDistance;
 newSelectedChildIndex = i;
 }
 }

 int newPos = mFirstPosition + newSelectedChildIndex;

 if (newPos != mSelectedPosition) {
 setSelectedPositionInt(newPos);
 setNextSelectedPositionInt(newPos);
 checkSelectionChanged();
 }
 }

 /**
 * Creates and positions all views for this Gallery.
 * 
 * We layout rarely, most of the time {@link #trackMotionScroll(int)} takes
 * care of repositioning, adding, and removing children.
 *
 * @param delta Change in the selected position. +1 means the selection is
 * moving to the right, so views are scrolling to the left. -1
 * means the selection is moving to the left.
 */
 @Override
 void layout(int delta, boolean animate) {

 int childrenLeft = mSpinnerPadding.left;
 int childrenWidth = mRight - mLeft - mSpinnerPadding.left - mSpinnerPadding.right;

 if (mDataChanged) {
 handleDataChanged();
 }

 // Handle an empty gallery by removing all views.
 if (mItemCount == 0) {
 resetList();
 return;
 }

 // Update to the new selected position.
 if (mNextSelectedPosition >= 0) {
 setSelectedPositionInt(mNextSelectedPosition);
 }

 // All views go in recycler while we are in layout
 recycleAllViews();

 // Clear out old views
 //removeAllViewsInLayout();
 detachAllViewsFromParent();

 /*
 * These will be used to give initial positions to views entering the
 * gallery as we scroll
 */
 mRightMost = 0;
 mLeftMost = 0;

 // Make selected view and center it

 /*
 * mFirstPosition will be decreased as we add views to the left later
 * on. The 0 for x will be offset in a couple lines down.
 */
 mFirstPosition = mSelectedPosition;
 View sel = makeAndAddView(mSelectedPosition, 0, 0, true);

 // Put the selected child in the center
 Gallery.LayoutParams lp = (Gallery.LayoutParams) sel.getLayoutParams();
 int selectedOffset = childrenLeft + (childrenWidth / 2) - (sel.getWidth() / 2);
 sel.offsetLeftAndRight(selectedOffset);

 fillToGalleryRight();
 fillToGalleryLeft();

 // Flush any cached views that did not get reused above
 mRecycler.clear();

 invalidate();
 checkSelectionChanged();

 mDataChanged = false;
 mNeedSync = false;
 setNextSelectedPositionInt(mSelectedPosition);

 updateSelectedItemMetadata();
 }

 private void fillToGalleryLeft() {
 int itemSpacing = mSpacing;
 int galleryLeft = mPaddingLeft;

 // Set state for initial iteration
 View prevIterationView = getChildAt(0);
 int curPosition;
 int curRightEdge;

 if (prevIterationView != null) {
 curPosition = mFirstPosition - 1;
 curRightEdge = prevIterationView.getLeft() - itemSpacing;
 } else {
 // No children available!
 curPosition = 0;
 curRightEdge = mRight - mLeft - mPaddingRight;
 mShouldStopFling = true;
 }

 while (curRightEdge > galleryLeft && curPosition >= 0) {
 prevIterationView = makeAndAddView(curPosition, curPosition - mSelectedPosition,
 curRightEdge, false);

 // Remember some state
 mFirstPosition = curPosition;

 // Set state for next iteration
 curRightEdge = prevIterationView.getLeft() - itemSpacing;
 curPosition--;
 }
 }

 private void fillToGalleryRight() {
 int itemSpacing = mSpacing;
 int galleryRight = mRight - mLeft - mPaddingRight;
 int numChildren = getChildCount();
 int numItems = mItemCount;

 // Set state for initial iteration
 View prevIterationView = getChildAt(numChildren - 1);
 int curPosition;
 int curLeftEdge;

 if (prevIterationView != null) {
 curPosition = mFirstPosition + numChildren;
 curLeftEdge = prevIterationView.getRight() + itemSpacing;
 } else {
 mFirstPosition = curPosition = mItemCount - 1;
 curLeftEdge = mPaddingLeft;
 mShouldStopFling = true;
 }

 while (curLeftEdge < galleryRight && curPosition < numItems) {
 prevIterationView = makeAndAddView(curPosition, curPosition - mSelectedPosition,
 curLeftEdge, true);

 // Set state for next iteration
 curLeftEdge = prevIterationView.getRight() + itemSpacing;
 curPosition++;
 }
 }

 /**
 * Obtain a view, either by pulling an existing view from the recycler or by
 * getting a new one from the adapter. If we are animating, make sure there
 * is enough information in the view's layout parameters to animate from the
 * old to new positions.
 *
 * @param position Position in the gallery for the view to obtain
 * @param offset Offset from the selected position
 * @param x X-coordintate indicating where this view should be placed. This
 * will either be the left or right edge of the view, depending on
 * the fromLeft paramter
 * @param fromLeft Are we posiitoning views based on the left edge? (i.e.,
 * building from left to right)?
 * @return A view that has been added to the gallery
 */
 private View makeAndAddView(int position, int offset, int x,
 boolean fromLeft) {

 View child;

 if (!mDataChanged) {
 child = mRecycler.get(position);
 if (child != null) {
 // Can reuse an existing view
 Gallery.LayoutParams lp = (Gallery.LayoutParams)
 child.getLayoutParams();

 int childLeft = child.getLeft();

 // Remember left and right edges of where views have been placed
 mRightMost = Math.max(mRightMost, childLeft
 + child.getMeasuredWidth());
 mLeftMost = Math.min(mLeftMost, childLeft);

 // Position the view
 setUpChild(child, offset, x, fromLeft);

 return child;
 }
 }

 // Nothing found in the recycler -- ask the adapter for a view
 child = mAdapter.getView(position, null, this);

 // Position the view
 setUpChild(child, offset, x, fromLeft);

 return child;
 }

 /**
 * Helper for makeAndAddView to set the position of a view and fill out its
 * layout paramters.
 *
 * @param child The view to position
 * @param offset Offset from the selected position
 * @param x X-coordintate indicating where this view should be placed. This
 * will either be the left or right edge of the view, depending on
 * the fromLeft paramter
 * @param fromLeft Are we posiitoning views based on the left edge? (i.e.,
 * building from left to right)?
 */
 private void setUpChild(View child, int offset, int x, boolean fromLeft) {

 // Respect layout params that are already in the view. Otherwise
 // make some up...
 Gallery.LayoutParams lp = (Gallery.LayoutParams)
 child.getLayoutParams();
 if (lp == null) {
 lp = (Gallery.LayoutParams) generateDefaultLayoutParams();
 }

 addViewInLayout(child, fromLeft ? -1 : 0, lp);

 child.setSelected(offset == 0);

 // Get measure specs
 int childHeightSpec = ViewGroup.getChildMeasureSpec(mHeightMeasureSpec,
 mSpinnerPadding.top + mSpinnerPadding.bottom, lp.height);
 int childWidthSpec = ViewGroup.getChildMeasureSpec(mWidthMeasureSpec,
 mSpinnerPadding.left + mSpinnerPadding.right, lp.width);

 // Measure child
 child.measure(childWidthSpec, childHeightSpec);

 int childLeft;
 int childRight;

 // Position vertically based on gravity setting
 int childTop = calculateTop(child, lp, true);
 int childBottom = childTop + child.getMeasuredHeight();

 int width = child.getMeasuredWidth();
 if (fromLeft) {
 childLeft = x;
 childRight = childLeft + width;
 } else {
 childLeft = x - width;
 childRight = x;
 }

 child.layout(childLeft, childTop, childRight, childBottom);
 }

 /**
 * Figure out vertical placement based on mGravity
 *
 * @param child Child to place
 * @param lp LayoutParams for this view (just so we don't keep looking them
 * up)
 * @return Where the top of the child should be
 */
 private int calculateTop(View child, Gallery.LayoutParams lp, boolean duringLayout) {
 int myHeight = duringLayout ? mMeasuredHeight : getHeight();
 int childHeight = duringLayout ? child.getMeasuredHeight() : child.getHeight();

 int childTop = 0;

 switch (mGravity) {
 case Gravity.TOP:
 childTop = mSpinnerPadding.top;
 break;
 case Gravity.CENTER_VERTICAL:
 int availableSpace = myHeight - mSpinnerPadding.bottom
 - mSpinnerPadding.top - childHeight;
 childTop = mSpinnerPadding.top + (availableSpace / 2);
 break;
 case Gravity.BOTTOM:
 childTop = myHeight - mSpinnerPadding.bottom - childHeight;
 break;
 }
 return childTop;
 }

 @Override
 public boolean onTouchEvent(MotionEvent event) {

 // Give everything to the gesture detector
 boolean retValue = mGestureDetector.onTouchEvent(event);

 int action = event.getAction();
 if (action == MotionEvent.ACTION_UP) {
 // Helper method for lifted finger
 onUp();
 } else if (action == MotionEvent.ACTION_CANCEL) {
 onCancel();
 }

 return retValue;
 }

 /**
 * {@inheritDoc}
 */
 public boolean onSingleTapUp(MotionEvent e) {

 if (mDownTouchPosition >= 0) {

 // An item tap should make it selected, so scroll to this child.
 scrollToChild(mDownTouchPosition - mFirstPosition);

 // Also pass the click so the client knows, if it wants to.
 if (mShouldCallbackOnUnselectedItemClick || mDownTouchPosition == mSelectedPosition) {
 performItemClick(mDownTouchView, mDownTouchPosition, mAdapter
 .getItemId(mDownTouchPosition));
 }

 return true;
 }

 return false;
 }

 /**
 * {@inheritDoc}
 */
 public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {

 if (!mShouldCallbackDuringFling) {
 // We want to suppress selection changes

 // Remove any future code to set mSuppressSelectionChanged = false
 removeCallbacks(mDisableSuppressSelectionChangedRunnable);

 // This will get reset once we scroll into slots
 if (!mSuppressSelectionChanged) mSuppressSelectionChanged = true;
 }

 // Fling the gallery!
 mFlingRunnable.startUsingVelocity((int) -velocityX);

 return true;
 }

 /**
 * {@inheritDoc}
 */
 public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {

 if (localLOGV) Log.v(TAG, String.valueOf(e2.getX() - e1.getX()));

 /*
 * Now's a good time to tell our parent to stop intercepting our events!
 * The user has moved more than the slop amount, since GestureDetector
 * ensures this before calling this method. Also, if a parent is more
 * interested in this touch's events than we are, it would have
 * intercepted them by now (for example, we can assume when a Gallery is
 * in the ListView, a vertical scroll would not end up in this method
 * since a ListView would have intercepted it by now).
 */
 mParent.requestDisallowInterceptTouchEvent(true);

 // As the user scrolls, we want to callback selection changes so related-
 // info on the screen is up-to-date with the gallery's selection
 if (!mShouldCallbackDuringFling) {
 if (mIsFirstScroll) {
 /*
 * We're not notifying the client of selection changes during
 * the fling, and this scroll could possibly be a fling. Don't
 * do selection changes until we're sure it is not a fling.
 */
 if (!mSuppressSelectionChanged) mSuppressSelectionChanged = true;
 postDelayed(mDisableSuppressSelectionChangedRunnable, SCROLL_TO_FLING_UNCERTAINTY_TIMEOUT);
 }
 } else {
 if (mSuppressSelectionChanged) mSuppressSelectionChanged = false;
 }

 // Track the motion
 trackMotionScroll(-1 * (int) distanceX);

 mIsFirstScroll = false;
 return true;
 }

 /**
 * {@inheritDoc}
 */
 public boolean onDown(MotionEvent e) {

 // Kill any existing fling/scroll
 mFlingRunnable.stop(false);

 // Get the item's view that was touched
 mDownTouchPosition = pointToPosition((int) e.getX(), (int) e.getY());

 if (mDownTouchPosition >= 0) {
 mDownTouchView = getChildAt(mDownTouchPosition - mFirstPosition);
 mDownTouchView.setPressed(true);
 }

 // Reset the multiple-scroll tracking state
 mIsFirstScroll = true;

 // Must return true to get matching events for this down event.
 return true;
 }

 /**
 * Called when a touch event's action is MotionEvent.ACTION_UP.
 */
 void onUp() {

 if (mFlingRunnable.mScroller.isFinished()) {
 scrollIntoSlots();
 }

 dispatchUnpress();
 }

 /**
 * Called when a touch event's action is MotionEvent.ACTION_CANCEL.
 */
 void onCancel() {
 onUp();
 }

 /**
 * {@inheritDoc}
 */
 public void onLongPress(MotionEvent e) {

 if (mDownTouchPosition < 0) {
 return;
 }

 performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
 long id = getItemIdAtPosition(mDownTouchPosition);
 dispatchLongPress(mDownTouchView, mDownTouchPosition, id);
 }

 // Unused methods from GestureDetector.OnGestureListener below

 /**
 * {@inheritDoc}
 */
 public void onShowPress(MotionEvent e) {
 }

 // Unused methods from GestureDetector.OnGestureListener above

 private void dispatchPress(View child) {

 if (child != null) {
 child.setPressed(true);
 }

 setPressed(true);
 }

 private void dispatchUnpress() {

 for (int i = getChildCount() - 1; i >= 0; i--) {
 getChildAt(i).setPressed(false);
 }

 setPressed(false);
 }

 @Override
 public void dispatchSetSelected(boolean selected) {
 /*
 * We don't want to pass the selected state given from its parent to its
 * children since this widget itself has a selected state to give to its
 * children.
 */
 }

 @Override
 protected void dispatchSetPressed(boolean pressed) {

 // Show the pressed state on the selected child
 if (mSelectedChild != null) {
 mSelectedChild.setPressed(pressed);
 }
 }

 @Override
 protected ContextMenuInfo getContextMenuInfo() {
 return mContextMenuInfo;
 }

 @Override
 public boolean showContextMenuForChild(View originalView) {

 final int longPressPosition = getPositionForView(originalView);
 if (longPressPosition < 0) {
 return false;
 }

 final long longPressId = mAdapter.getItemId(longPressPosition);
 return dispatchLongPress(originalView, longPressPosition, longPressId);
 }

 @Override
 public boolean showContextMenu() {

 if (isPressed() && mSelectedPosition >= 0) {
 int index = mSelectedPosition - mFirstPosition;
 View v = getChildAt(index);
 return dispatchLongPress(v, mSelectedPosition, mSelectedRowId);
 }

 return false;
 }

 private boolean dispatchLongPress(View view, int position, long id) {
 boolean handled = false;

 if (mOnItemLongClickListener != null) {
 handled = mOnItemLongClickListener.onItemLongClick(this, mDownTouchView,
 mDownTouchPosition, id);
 }

 if (!handled) {
 mContextMenuInfo = new AdapterContextMenuInfo(view, position, id);
 handled = super.showContextMenuForChild(this);
 }

 if (handled) {
 performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
 }

 return handled;
 }

 @Override
 public boolean dispatchKeyEvent(KeyEvent event) {
 // Gallery steals all key events
 return event.dispatch(this);
 }

 /**
 * Handles left, right, and clicking
 * @see android.view.View#onKeyDown
 */
 @Override
 public boolean onKeyDown(int keyCode, KeyEvent event) {
 switch (keyCode) {

 case KeyEvent.KEYCODE_DPAD_LEFT:
 if (movePrevious()) {
 playSoundEffect(SoundEffectConstants.NAVIGATION_LEFT);
 }
 return true;

 case KeyEvent.KEYCODE_DPAD_RIGHT:
 if (moveNext()) {
 playSoundEffect(SoundEffectConstants.NAVIGATION_RIGHT);
 }
 return true;

 case KeyEvent.KEYCODE_DPAD_CENTER:
 case KeyEvent.KEYCODE_ENTER:
 mReceivedInvokeKeyDown = true;
 // fallthrough to default handling
 }

 return super.onKeyDown(keyCode, event);
 }

 @Override
 public boolean onKeyUp(int keyCode, KeyEvent event) {
 switch (keyCode) {
 case KeyEvent.KEYCODE_DPAD_CENTER:
 case KeyEvent.KEYCODE_ENTER: {

 if (mReceivedInvokeKeyDown) {
 if (mItemCount > 0) {

 dispatchPress(mSelectedChild);
 postDelayed(new Runnable() {
 public void run() {
 dispatchUnpress();
 }
 }, ViewConfiguration.getPressedStateDuration());

 int selectedIndex = mSelectedPosition - mFirstPosition;
 performItemClick(getChildAt(selectedIndex), mSelectedPosition, mAdapter
 .getItemId(mSelectedPosition));
 }
 }

 // Clear the flag
 mReceivedInvokeKeyDown = false;

 return true;
 }
 }

 return super.onKeyUp(keyCode, event);
 }

 boolean movePrevious() {
 if (mItemCount > 0 && mSelectedPosition > 0) {
 scrollToChild(mSelectedPosition - mFirstPosition - 1);
 return true;
 } else {
 return false;
 }
 }

 boolean moveNext() {
 if (mItemCount > 0 && mSelectedPosition < mItemCount - 1) {
 scrollToChild(mSelectedPosition - mFirstPosition + 1);
 return true;
 } else {
 return false;
 }
 }

 private boolean scrollToChild(int childPosition) {
 View child = getChildAt(childPosition);

 if (child != null) {
 int distance = getCenterOfGallery() - getCenterOfView(child);
 mFlingRunnable.startUsingDistance(distance);
 return true;
 }

 return false;
 }

 @Override
 void setSelectedPositionInt(int position) {
 super.setSelectedPositionInt(position);

 // Updates any metadata we keep about the selected item.
 updateSelectedItemMetadata();
 }

 private void updateSelectedItemMetadata() {

 View oldSelectedChild = mSelectedChild;

 View child = mSelectedChild = getChildAt(mSelectedPosition - mFirstPosition);
 if (child == null) {
 return;
 }

 child.setSelected(true);
 child.setFocusable(true);

 if (hasFocus()) {
 child.requestFocus();
 }

 // We unfocus the old child down here so the above hasFocus check
 // returns true
 if (oldSelectedChild != null) {

 // Make sure its drawable state doesn't contain 'selected'
 oldSelectedChild.setSelected(false);

 // Make sure it is not focusable anymore, since otherwise arrow keys
 // can make this one be focused
 oldSelectedChild.setFocusable(false);
 }

 }

 /**
 * Describes how the child views are aligned.
 * @param gravity
 *
 * @attr ref android.R.styleable#Gallery_gravity
 */
 public void setGravity(int gravity)
 {
 if (mGravity != gravity) {
 mGravity = gravity;
 requestLayout();
 }
 }

 @Override
 protected int getChildDrawingOrder(int childCount, int i) {
 int selectedIndex = mSelectedPosition - mFirstPosition;

 // Just to be safe
 if (selectedIndex < 0) return i;

 if (i == childCount - 1) {
 // Draw the selected child last
 return selectedIndex;
 } else if (i >= selectedIndex) {
 // Move the children to the right of the selected child earlier one
 return i + 1;
 } else {
 // Keep the children to the left of the selected child the same
 return i;
 }
 }

 @Override
 protected void onFocusChanged(boolean gainFocus, int direction, Rect previouslyFocusedRect) {
 super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);

 /*
 * The gallery shows focus by focusing the selected item. So, give
 * focus to our selected item instead. We steal keys from our
 * selected item elsewhere.
 */
 if (gainFocus && mSelectedChild != null) {
 mSelectedChild.requestFocus(direction);
 }

 }

 /**
 * Responsible for fling behavior. Use {@link #startUsingVelocity(int)} to
 * initiate a fling. Each frame of the fling is handled in {@link #run()}.
 * A FlingRunnable will keep re-posting itself until the fling is done.
 *
 */
 private class FlingRunnable implements Runnable {
 /**
 * Tracks the decay of a fling scroll
 */
 private Scroller mScroller;

 /**
 * X value reported by mScroller on the previous fling
 */
 private int mLastFlingX;

 public FlingRunnable() {
 mScroller = new Scroller(getContext());
 }

 private void startCommon() {
 // Remove any pending flings
 removeCallbacks(this);
 }

 public void startUsingVelocity(int initialVelocity) {
 if (initialVelocity == 0) return;

 startCommon();

 int initialX = initialVelocity < 0 ? Integer.MAX_VALUE : 0;
 mLastFlingX = initialX;
 mScroller.fling(initialX, 0, initialVelocity, 0,
 0, Integer.MAX_VALUE, 0, Integer.MAX_VALUE);
 post(this);
 }

 public void startUsingDistance(int distance) {
 if (distance == 0) return;

 startCommon();

 mLastFlingX = 0;
 mScroller.startScroll(0, 0, -distance, 0, mAnimationDuration);
 post(this);
 }

 public void stop(boolean scrollIntoSlots) {
 removeCallbacks(this);
 endFling(scrollIntoSlots);
 }

 private void endFling(boolean scrollIntoSlots) {
 /*
 * Force the scroller's status to finished (without setting its
 * position to the end)
 */
 mScroller.forceFinished(true);

 if (scrollIntoSlots) scrollIntoSlots();
 }

 public void run() {

 if (mItemCount == 0) {
 endFling(true);
 return;
 }

 mShouldStopFling = false;

 final Scroller scroller = mScroller;
 boolean more = scroller.computeScrollOffset();
 final int x = scroller.getCurrX();

 // Flip sign to convert finger direction to list items direction
 // (e.g. finger moving down means list is moving towards the top)
 int delta = mLastFlingX - x;

 // Pretend that each frame of a fling scroll is a touch scroll
 if (delta > 0) {
 // Moving towards the left. Use first view as mDownTouchPosition
 mDownTouchPosition = mFirstPosition;

 // Don't fling more than 1 screen
 delta = Math.min(getWidth() - mPaddingLeft - mPaddingRight - 1, delta);
 } else {
 // Moving towards the right. Use last view as mDownTouchPosition
 int offsetToLast = getChildCount() - 1;
 mDownTouchPosition = mFirstPosition + offsetToLast;

 // Don't fling more than 1 screen
 delta = Math.max(-(getWidth() - mPaddingRight - mPaddingLeft - 1), delta);
 }

 trackMotionScroll(delta);

 if (more && !mShouldStopFling) {
 mLastFlingX = x;
 post(this);
 } else {
 endFling(true);
 }
 }

 }

 /**
 * Gallery extends LayoutParams to provide a place to hold current
 * Transformation information along with previous position/transformation
 * info.
 *
 */
 public static class LayoutParams extends ViewGroup.LayoutParams {
 public LayoutParams(Context c, AttributeSet attrs) {
 super(c, attrs);
 }

 public LayoutParams(int w, int h) {
 super(w, h);
 }

 public LayoutParams(ViewGroup.LayoutParams source) {
 super(source);
 }
 }
}

저작자표시

Posted by 빈솔B

,

VideoView.java Source

Android/Android Platform 2010. 3. 22. 12:00

/*
* Copyright (C) 2006 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 android.widget;

import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.res.Resources;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnCompletionListener;
import android.media.MediaPlayer.OnErrorListener;
import android.net.Uri;
import android.os.PowerManager;
import android.util.AttributeSet;
import android.util.Log;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.widget.MediaController.MediaPlayerControl;

import java.io.IOException;

/**
* Displays a video file. The VideoView class
* can load images from various sources (such as resources or content
* providers), takes care of computing its measurement from the video so that
* it can be used in any layout manager, and provides various display options
* such as scaling and tinting.
*/
public class VideoView extends SurfaceView implements MediaPlayerControl {
 private String TAG = "VideoView";
 // settable by the client
 private Uri mUri;
 private int mDuration;

 // All the stuff we need for playing and showing a video
 private SurfaceHolder mSurfaceHolder = null;
 private MediaPlayer mMediaPlayer = null;
 private boolean mIsPrepared;
 private boolean mIsPlaybackCompleted;
 private int mVideoWidth;
 private int mVideoHeight;
 private int mSurfaceWidth;
 private int mSurfaceHeight;
 private MediaController mMediaController;
 private OnCompletionListener mOnCompletionListener;
 private MediaPlayer.OnPreparedListener mOnPreparedListener;
 private int mCurrentBufferPercentage;
 private OnErrorListener mOnErrorListener;
 private boolean mStartWhenPrepared;
 private int mSeekWhenPrepared;

 public VideoView(Context context) {
 super(context);
 initVideoView();
 }

 public VideoView(Context context, AttributeSet attrs) {
 this(context, attrs, 0);
 initVideoView();
 }

 public VideoView(Context context, AttributeSet attrs, int defStyle) {
 super(context, attrs, defStyle);

 initVideoView();
 }

 @Override
 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
 //Log.i("@@@@", "onMeasure");
 int width = getDefaultSize(mVideoWidth, widthMeasureSpec);
 int height = getDefaultSize(mVideoHeight, heightMeasureSpec);
 if (mVideoWidth > 0 && mVideoHeight > 0) {
 if ( mVideoWidth * height > width * mVideoHeight ) {
 //Log.i("@@@", "image too tall, correcting");
 height = width * mVideoHeight / mVideoWidth;
 } else if ( mVideoWidth * height < width * mVideoHeight ) {
 //Log.i("@@@", "image too wide, correcting");
 width = height * mVideoWidth / mVideoHeight;
 } else {
 //Log.i("@@@", "aspect ratio is correct: " +
 //width+"/"+height+"="+
 //mVideoWidth+"/"+mVideoHeight);
 }
 }
 //Log.i("@@@@@@@@@@", "setting size: " + width + 'x' + height);
 setMeasuredDimension(width, height);
 }

 public int resolveAdjustedSize(int desiredSize, int measureSpec) {
 int result = desiredSize;
 int specMode = MeasureSpec.getMode(measureSpec);
 int specSize = MeasureSpec.getSize(measureSpec);

 switch (specMode) {
 case MeasureSpec.UNSPECIFIED:
 /* Parent says we can be as big as we want. Just don't be larger
 * than max size imposed on ourselves.
 */
 result = desiredSize;
 break;

 case MeasureSpec.AT_MOST:
 /* Parent says we can be as big as we want, up to specSize.
 * Don't be larger than specSize, and don't be larger than
 * the max size imposed on ourselves.
 */
 result = Math.min(desiredSize, specSize);
 break;

 case MeasureSpec.EXACTLY:
 // No choice. Do what we are told.
 result = specSize;
 break;
 }
 return result;
}

 private void initVideoView() {
 mVideoWidth = 0;
 mVideoHeight = 0;
 getHolder().addCallback(mSHCallback);
 getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
 setFocusable(true);
 setFocusableInTouchMode(true);
 requestFocus();
 }

 public void setVideoPath(String path) {
 setVideoURI(Uri.parse(path));
 }

 public void setVideoURI(Uri uri) {
 mUri = uri;
 mStartWhenPrepared = false;
 mSeekWhenPrepared = 0;
 openVideo();
 requestLayout();
 invalidate();
 }

 public void stopPlayback() {
 if (mMediaPlayer != null) {
 mMediaPlayer.stop();
 mMediaPlayer.release();
 mMediaPlayer = null;
 }
 }

 private void openVideo() {
 if (mUri == null || mSurfaceHolder == null) {
 // not ready for playback just yet, will try again later
 return;
 }
 // Tell the music playback service to pause
 // TODO: these constants need to be published somewhere in the framework.
 Intent i = new Intent("com.android.music.musicservicecommand");
 i.putExtra("command", "pause");
 mContext.sendBroadcast(i);

 if (mMediaPlayer != null) {
 mMediaPlayer.reset();
 mMediaPlayer.release();
 mMediaPlayer = null;
 }
 try {
 mMediaPlayer = new MediaPlayer();
 mMediaPlayer.setOnPreparedListener(mPreparedListener);
 mMediaPlayer.setOnVideoSizeChangedListener(mSizeChangedListener);
 mIsPrepared = false;
 Log.v(TAG, "reset duration to -1 in openVideo");
 mDuration = -1;
 mMediaPlayer.setOnCompletionListener(mCompletionListener);
 mMediaPlayer.setOnErrorListener(mErrorListener);
 mMediaPlayer.setOnBufferingUpdateListener(mBufferingUpdateListener);
 mCurrentBufferPercentage = 0;
 mMediaPlayer.setDataSource(mContext, mUri);
 mMediaPlayer.setDisplay(mSurfaceHolder);
 mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
 mMediaPlayer.setScreenOnWhilePlaying(true);
 mMediaPlayer.prepareAsync();
 attachMediaController();
 } catch (IOException ex) {
 Log.w(TAG, "Unable to open content: " + mUri, ex);
 return;
 } catch (IllegalArgumentException ex) {
 Log.w(TAG, "Unable to open content: " + mUri, ex);
 return;
 }
 }

 public void setMediaController(MediaController controller) {
 if (mMediaController != null) {
 mMediaController.hide();
 }
 mMediaController = controller;
 attachMediaController();
 }

 private void attachMediaController() {
 if (mMediaPlayer != null && mMediaController != null) {
 mMediaController.setMediaPlayer(this);
 View anchorView = this.getParent() instanceof View ?
 (View)this.getParent() : this;
 mMediaController.setAnchorView(anchorView);
 mMediaController.setEnabled(mIsPrepared);
 }
 }

 MediaPlayer.OnVideoSizeChangedListener mSizeChangedListener =
 new MediaPlayer.OnVideoSizeChangedListener() {
 public void onVideoSizeChanged(MediaPlayer mp, int width, int height) {
 mVideoWidth = mp.getVideoWidth();
 mVideoHeight = mp.getVideoHeight();
 if (mVideoWidth != 0 && mVideoHeight != 0) {
 getHolder().setFixedSize(mVideoWidth, mVideoHeight);
 }
 }
 };

 MediaPlayer.OnPreparedListener mPreparedListener = new MediaPlayer.OnPreparedListener() {
 public void onPrepared(MediaPlayer mp) {
 // briefly show the mediacontroller
 mIsPrepared = true;
 if (mOnPreparedListener != null) {
 mOnPreparedListener.onPrepared(mMediaPlayer);
 }
 if (mMediaController != null) {
 mMediaController.setEnabled(true);
 }
 mVideoWidth = mp.getVideoWidth();
 mVideoHeight = mp.getVideoHeight();
 if (mVideoWidth != 0 && mVideoHeight != 0) {
 //Log.i("@@@@", "video size: " + mVideoWidth +"/"+ mVideoHeight);
 getHolder().setFixedSize(mVideoWidth, mVideoHeight);
 if (mSurfaceWidth == mVideoWidth && mSurfaceHeight == mVideoHeight) {
 // We didn't actually change the size (it was already at the size
 // we need), so we won't get a "surface changed" callback, so
 // start the video here instead of in the callback.
 if (mSeekWhenPrepared != 0) {
 mMediaPlayer.seekTo(mSeekWhenPrepared);
 mSeekWhenPrepared = 0;
 }
 if (mStartWhenPrepared) {
 start();
 mStartWhenPrepared = false;
 if (mMediaController != null) {
 mMediaController.show();
 }
 } else if (!isPlaying() &&
 (mSeekWhenPrepared != 0 || getCurrentPosition() > 0)) {
 if (mMediaController != null) {
 // Show the media controls when we're paused into a video and make 'em stick.
 mMediaController.show(0);
 }
 }
 }
 } else {
 // We don't know the video size yet, but should start anyway.
 // The video size might be reported to us later.
 if (mSeekWhenPrepared != 0) {
 mMediaPlayer.seekTo(mSeekWhenPrepared);
 mSeekWhenPrepared = 0;
 }
 if (mStartWhenPrepared) {
 start();
 mStartWhenPrepared = false;
 }
 }
 }
 };

 private MediaPlayer.OnCompletionListener mCompletionListener =
 new MediaPlayer.OnCompletionListener() {
 public void onCompletion(MediaPlayer mp) {
 mIsPlaybackCompleted = true;
 if (mMediaController != null) {
 mMediaController.hide();
 }
 if (mOnCompletionListener != null) {
 mOnCompletionListener.onCompletion(mMediaPlayer);
 }
 }
 };

 private MediaPlayer.OnErrorListener mErrorListener =
 new MediaPlayer.OnErrorListener() {
 public boolean onError(MediaPlayer mp, int framework_err, int impl_err) {
 Log.d(TAG, "Error: " + framework_err + "," + impl_err);
 if (mMediaController != null) {
 mMediaController.hide();
 }

 /* If an error handler has been supplied, use it and finish. */
 if (mOnErrorListener != null) {
 if (mOnErrorListener.onError(mMediaPlayer, framework_err, impl_err)) {
 return true;
 }
 }

 /* Otherwise, pop up an error dialog so the user knows that
 * something bad has happened. Only try and pop up the dialog
 * if we're attached to a window. When we're going away and no
 * longer have a window, don't bother showing the user an error.
 */
 if (getWindowToken() != null) {
 Resources r = mContext.getResources();
 int messageId;

 if (framework_err == MediaPlayer.MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK) {
 messageId = com.android.internal.R.string.VideoView_error_text_invalid_progressive_playback;
 } else {
 messageId = com.android.internal.R.string.VideoView_error_text_unknown;
 }

 new AlertDialog.Builder(mContext)
 .setTitle(com.android.internal.R.string.VideoView_error_title)
 .setMessage(messageId)
 .setPositiveButton(com.android.internal.R.string.VideoView_error_button,
 new DialogInterface.OnClickListener() {
 public void onClick(DialogInterface dialog, int whichButton) {
 /* If we get here, there is no onError listener, so
 * at least inform them that the video is over.
 */
 if (mOnCompletionListener != null) {
 mOnCompletionListener.onCompletion(mMediaPlayer);
 }
 }
 })
 .setCancelable(false)
 .show();
 }
 return true;
 }
 };

 private MediaPlayer.OnBufferingUpdateListener mBufferingUpdateListener =
 new MediaPlayer.OnBufferingUpdateListener() {
 public void onBufferingUpdate(MediaPlayer mp, int percent) {
 mCurrentBufferPercentage = percent;
 }
 };

 /**
 * Register a callback to be invoked when the media file
 * is loaded and ready to go.
 *
 * @param l The callback that will be run
 */
 public void setOnPreparedListener(MediaPlayer.OnPreparedListener l)
 {
 mOnPreparedListener = l;
 }

 /**
 * Register a callback to be invoked when the end of a media file
 * has been reached during playback.
 *
 * @param l The callback that will be run
 */
 public void setOnCompletionListener(OnCompletionListener l)
 {
 mOnCompletionListener = l;
 }

 /**
 * Register a callback to be invoked when an error occurs
 * during playback or setup. If no listener is specified,
 * or if the listener returned false, VideoView will inform
 * the user of any errors.
 *
 * @param l The callback that will be run
 */
 public void setOnErrorListener(OnErrorListener l)
 {
 mOnErrorListener = l;
 }

 SurfaceHolder.Callback mSHCallback = new SurfaceHolder.Callback()
 {
 public void surfaceChanged(SurfaceHolder holder, int format,
 int w, int h)
 {
 mSurfaceWidth = w;
 mSurfaceHeight = h;
 if (mMediaPlayer != null && mIsPrepared && mVideoWidth == w && mVideoHeight == h) {
 if (mSeekWhenPrepared != 0) {
 mMediaPlayer.seekTo(mSeekWhenPrepared);
 mSeekWhenPrepared = 0;
 }
 if (!mIsPlaybackCompleted) {
 start();
 }
 if (mMediaController != null) {
 mMediaController.show();
 }
 }
 }

 public void surfaceCreated(SurfaceHolder holder)
 {
 mSurfaceHolder = holder;
 openVideo();
 }

 public void surfaceDestroyed(SurfaceHolder holder)
 {
 // after we return from this we can't use the surface any more
 mSurfaceHolder = null;
 if (mMediaController != null) mMediaController.hide();
 if (mMediaPlayer != null) {
 mMediaPlayer.reset();
 mMediaPlayer.release();
 mMediaPlayer = null;
 }
 }
 };

 @Override
 public boolean onTouchEvent(MotionEvent ev) {
 if (mIsPrepared && mMediaPlayer != null && mMediaController != null) {
 toggleMediaControlsVisiblity();
 }
 return false;
 }

 @Override
 public boolean onTrackballEvent(MotionEvent ev) {
 if (mIsPrepared && mMediaPlayer != null && mMediaController != null) {
 toggleMediaControlsVisiblity();
 }
 return false;
 }

 @Override
 public boolean onKeyDown(int keyCode, KeyEvent event)
 {
 if (mIsPrepared &&
 keyCode != KeyEvent.KEYCODE_BACK &&
 keyCode != KeyEvent.KEYCODE_VOLUME_UP &&
 keyCode != KeyEvent.KEYCODE_VOLUME_DOWN &&
 keyCode != KeyEvent.KEYCODE_MENU &&
 keyCode != KeyEvent.KEYCODE_CALL &&
 keyCode != KeyEvent.KEYCODE_ENDCALL &&
 mMediaPlayer != null &&
 mMediaController != null) {
 if (keyCode == KeyEvent.KEYCODE_HEADSETHOOK ||
 keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) {
 if (mMediaPlayer.isPlaying()) {
 pause();
 mMediaController.show();
 } else {
 start();
 mMediaController.hide();
 }
 return true;
 } else if (keyCode == KeyEvent.KEYCODE_MEDIA_STOP
 && mMediaPlayer.isPlaying()) {
 pause();
 mMediaController.show();
 } else {
 toggleMediaControlsVisiblity();
 }
 }

 return super.onKeyDown(keyCode, event);
 }

 private void toggleMediaControlsVisiblity() {
 if (mMediaController.isShowing()) {
 mMediaController.hide();
 } else {
 mMediaController.show();
 }
 }

 public void start() {
 mIsPlaybackCompleted = false;
 if (mMediaPlayer != null && mIsPrepared) {
 mMediaPlayer.start();
 mStartWhenPrepared = false;
 } else {
 mStartWhenPrepared = true;
 }
 }

 public void pause() {
 if (mMediaPlayer != null && mIsPrepared) {
 if (mMediaPlayer.isPlaying()) {
 mMediaPlayer.pause();
 }
 }
 mStartWhenPrepared = false;
 }

 public int getDuration() {
 if (mMediaPlayer != null && mIsPrepared) {
 if (mDuration > 0) {
 return mDuration;
 }
 mDuration = mMediaPlayer.getDuration();
 return mDuration;
 }
 mDuration = -1;
 return mDuration;
 }

 public int getCurrentPosition() {
 if (mMediaPlayer != null && mIsPrepared) {
 return mMediaPlayer.getCurrentPosition();
 }
 return 0;
 }

 public void seekTo(int msec) {
 if (mMediaPlayer != null && mIsPrepared) {
 mMediaPlayer.seekTo(msec);
 } else {
 mSeekWhenPrepared = msec;
 }
 }

 public boolean isPlaying() {
 if (mMediaPlayer != null && mIsPrepared) {
 return mMediaPlayer.isPlaying();
 }
 return false;
 }

 public int getBufferPercentage() {
 if (mMediaPlayer != null) {
 return mCurrentBufferPercentage;
 }
 return 0;
 }
}

저작자표시

Posted by 빈솔B

,

How to align on EditText

Android/Android Development 2010. 2. 3. 16:59

EditText 내에 쓰여지는 스트링 구문을 오른쪽, 중앙, 왼쪽 정렬을 하고 싶으시면 아래와 같이 하면됩니다.

On xml layout

android:gravity="right"

On code

EditText content = new EditText(this);
...
content.setGravity(Gravity.RIGHT);
...

별탈없이 잘될겁니다.

저작자표시

Posted by 빈솔B

,

How to control soft keyboard(InputMethodManager), hide or show

Android/Android Development 2010. 1. 3. 12:11

가상 키보드를 강제로 보이게 하고 또 안보이게 하는 방법입니다.

InputMethodManager imm;

@Override
public void onCreate(Bundle icicle) {
TimerTask myTask = new TimerTask(){
public void run(){
imm = (InputMethodManager)getSystemService(INPUT_METHOD_SERVICE); imm.showSoftInput(getCurrentFocus(), InputMethodManager.SHOW_FORCED);
}
};

Timer timer = new Timer();
timer.schedule(myTask, 500);

@Override
protected void onPause() {
super.onPause(); imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
}

위의 액티비티가 포어그라운드로 실행될 때 InputMethodService 의 참조를 얻어서 가상 키패드를 보여주는 메소드를 차례로 호출하고 있습니다. 그리고 위 액티비티가 백그라운드로 실행되면 onPouse를 내에 가상 키패드를 감추는 메소드를 호출하게 되어있습니다.

어려운 것은 없지만 왜 타이머 안에 구현되어 있느냐가 중요합니다.

기본적으로 키보드는 OS 단에서 지원되는 것이기때문에 아무곳에나 붙이기는 어렵습니다. 그리고 액티비티 생성시 바로 호출하게되면 뜨지 않습니다.(제 생각엔, 아마 내부적으로 onCreate 작업의 막바지거나 끝나고 수행되는듯 합니다.) 그래서 타이머나 핸들러로 약간의 딜레이 주는 작업이 불가피합니다.

저작자표시

Posted by 빈솔B

,

How to convert Layout Property on Xml to dynamic code.

Android/Android UI 2010. 1. 3. 02:09

Layout Xml로 구현한 Layout 속성 (width, height, weight, marginLeft, marginRight)이 있습니다.

위의 Layout Xml로 구현한 Layout 속성을 동적 코드로 만들면 아래와 같습니다.

EditText content = new EditText(getBaseContext());
MarginLayoutParams marginCotent = new ViewGroup.MarginLayoutParams( LinearLayout.LayoutParams.FILL_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT );
marginCotent.setMargins( 1, 1, 0, 0 );
content.setLayoutParams( new LinearLayout.LayoutParams( marginCotent ) );
content.setBackgroundColor(Color.LTGRAY);
content.setGravity(Gravity.LEFT);
content.setFreezesText(true);
content.requestFocus();

마진 수치가 완전히 일치하진 않습니다. 유의하기 바랍니다.

눈여겨 볼게 하나 있는데 requestFocus 되어 있으면 해당 텍스트에디터에 자동 포커싱되게 됩니다.

저작자표시

Posted by 빈솔B

,

How difference between customer Resource.Color and Android.graphics.Color?

Android/Android UI 2010. 1. 3. 00:02

사용자가 만든 컬러 코드는 왜 안먹히고 안드로이드 내장 라이브러리 컬러 코드는 먹히는가?

사용자가 만든 컬러코드 res/values/color.xml 내부 코드 입니다.

<resources>
<color name="solid_red">#f00</color>
<color name="solid_blue">#0000ff</color>
<color name="solid_green">#f0f0</color>
<color name="solid_yellow">#ffffff00</color>
</resources>

아래와 같이 xml 레이아웃 통한 설정은 잘 동작합니다.

하지만 아래와 같이 동적생성일 경우엔 오브젝트 생성후 속성 세팅으로는 이상하게 커스텀 컬러 코드로는 동작하지 않습니다. 안드로이드 내장 라이브러리 컬러 코드로 해야 적용이 제대로 됩니다.

LinearLayout info = new LinearLayout(this);

//customer Resource.Color
info.setBackgroundColor(R.color.solid_yellow);

//Android.graphics.Color
info.setBackgroundColor(Color.WHITE);

왜이럴까;; 원래 이런건가;;

언젠가 알날이 오것지.. 씁쓸하구만.. 아깝다 내 두시간..

저작자표시

Posted by 빈솔B

,

'Android'에 해당되는 글 35건

scrolling listview loses background color/drawable

How to defines which edges should be fadeded on scrolling.

MediaPlayer.java Source

MediaController.java Source

Gallery.java Source

VideoView.java Source

How to align on EditText

How to control soft keyboard(InputMethodManager), hide or show

How to convert Layout Property on Xml to dynamic code.

How difference between customer Resource.Color and Android.graphics.Color?

카테고리

태그목록

최근에 올라온 글

최근에 달린 댓글

최근에 받은 트랙백

글 보관함

달력

링크

티스토리툴바