SlideshowActivity.java

/*
 * Copyright (C) 2008 Esmertec AG.
 * Copyright (C) 2008 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 cn.edu.tsinghua.hpc.tmms.ui;

import java.io.ByteArrayOutputStream;

import org.w3c.dom.events.Event;
import org.w3c.dom.events.EventListener;
import org.w3c.dom.events.EventTarget;
import org.w3c.dom.smil.SMILDocument;

import android.app.Activity;
import android.content.Intent;
import android.graphics.PixelFormat;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.util.Config;
import android.util.Log;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.Window;
import android.widget.MediaController;
import android.widget.MediaController.MediaPlayerControl;
import cn.edu.tsinghua.hpc.google.tmms.InvalidHeaderValueException;
import cn.edu.tsinghua.hpc.google.tmms.MmsException;
import cn.edu.tsinghua.hpc.tmms.R;
import cn.edu.tsinghua.hpc.tmms.dom.smil.SmilDocumentImpl;
import cn.edu.tsinghua.hpc.tmms.dom.smil.SmilPlayer;
import cn.edu.tsinghua.hpc.tmms.dom.smil.parser.SmilXmlSerializer;
import cn.edu.tsinghua.hpc.tmms.model.SlideshowModel;
import cn.edu.tsinghua.hpc.tmms.model.SmilHelper;


/**
 * Plays the given slideshow in full-screen mode with a common controller.
 */
public class SlideshowActivity extends Activity implements EventListener {
    private static final String TAG = "SlideshowActivity";
    private static final boolean DEBUG = false;
    private static final boolean LOCAL_LOGV = DEBUG ? Config.LOGD : Config.LOGV;

    private MediaController mMediaController;
    private SmilPlayer mSmilPlayer;

    private Handler mHandler;

    private SMILDocument mSmilDoc;

	@Override
	public void onCreate(Bundle icicle) {
		super.onCreate(icicle);
		mHandler = new Handler();

		// Play slide-show in full-screen mode.
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		getWindow().setFormat(PixelFormat.TRANSLUCENT);
		setContentView(R.layout.slideshow);

		Intent intent = getIntent();
		Uri msg = intent.getData();
		final SlideshowModel model;

		try {
			model = SlideshowModel.createFromMessageUri(this, msg);

			SlideView view = (SlideView) findViewById(R.id.slide_view);
			PresenterFactory.getPresenter("SlideshowPresenter", this, view,
					model);

			mHandler.post(new Runnable() {
				private boolean isRotating() {
					return mSmilPlayer.isPausedState()
							|| mSmilPlayer.isPlayingState()
							|| mSmilPlayer.isPlayedState();
				}

				public void run() {
					mSmilPlayer = SmilPlayer.getPlayer();
					initMediaController();

					// Use SmilHelper.getDocument() to ensure rebuilding the
					// entire SMIL document.
					mSmilDoc = SmilHelper.getDocument(model);
					if (DEBUG) {
						ByteArrayOutputStream ostream = new ByteArrayOutputStream();
						SmilXmlSerializer.serialize(mSmilDoc, ostream);
						if (LOCAL_LOGV) {
							Log.v(TAG, ostream.toString());
						}
					}

					// Add event listener.
					((EventTarget) mSmilDoc).addEventListener(
							SmilDocumentImpl.SMIL_DOCUMENT_END_EVENT,
							SlideshowActivity.this, false);

					mSmilPlayer.init(mSmilDoc);
					if (isRotating()) {
						mSmilPlayer.reload();
					} else {
						mSmilPlayer.play();
					}
				}
			});
		} catch (MmsException e) {
			Log.e(TAG, "Cannot present the slide show.", e);
			finish();
			return;
		} catch (InvalidHeaderValueException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

    private void initMediaController() {
        mMediaController = new MediaController(SlideshowActivity.this, false);
        mMediaController.setMediaPlayer(new SmilPlayerController(mSmilPlayer));
        mMediaController.setAnchorView(findViewById(R.id.slide_view));
    }

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        if ((mSmilPlayer != null) && (mMediaController != null)) {
            mMediaController.show();
        }
        return false;
    }

    @Override
    protected void onPause() {
        super.onPause();
        if (mSmilDoc != null) {
            ((EventTarget) mSmilDoc).removeEventListener(
                    SmilDocumentImpl.SMIL_DOCUMENT_END_EVENT, this, false);
        }
    }

    @Override
    protected void onStop() {
        super.onStop();
        if ((null != mSmilPlayer)) {
            if (isFinishing()) {
                mSmilPlayer.stop();
            } else {
                mSmilPlayer.stopWhenReload();
            }
            if (mMediaController != null) {
                // Must do this so we don't leak a window.
                mMediaController.hide();
            }
        }
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        switch (keyCode) {
            case KeyEvent.KEYCODE_VOLUME_DOWN:
            case KeyEvent.KEYCODE_VOLUME_UP:
            case KeyEvent.KEYCODE_DPAD_UP:
            case KeyEvent.KEYCODE_DPAD_DOWN:
            case KeyEvent.KEYCODE_DPAD_LEFT:
            case KeyEvent.KEYCODE_DPAD_RIGHT:
                break;
            case KeyEvent.KEYCODE_BACK:
            case KeyEvent.KEYCODE_MENU:
                if ((mSmilPlayer != null) &&
                        (mSmilPlayer.isPausedState()
                        || mSmilPlayer.isPlayingState()
                        || mSmilPlayer.isPlayedState())) {
                    mSmilPlayer.stop();
                }
                break;
            default:
                if ((mSmilPlayer != null) && (mMediaController != null)) {
                    mMediaController.show();
                }
        }
        return super.onKeyDown(keyCode, event);
    }

    private class SmilPlayerController implements MediaPlayerControl {
        private final SmilPlayer mPlayer;

        public SmilPlayerController(SmilPlayer player) {
            mPlayer = player;
        }

        public int getBufferPercentage() {
            // We don't need to buffer data, always return 100%.
            return 100;
        }

        public int getCurrentPosition() {
            return mPlayer.getCurrentPosition();
        }

        public int getDuration() {
            return mPlayer.getDuration();
        }

        public boolean isPlaying() {
            return mPlayer != null ? mPlayer.isPlayingState() : false;
        }

        public void pause() {
            if (mPlayer != null) {
                mPlayer.pause();
            }
        }

        public void seekTo(int pos) {
            // Don't need to support.
        }

        public void start() {
            if (mPlayer != null) {
                mPlayer.start();
            }
        }

        public boolean canPause() {
            return true;
        }

        public boolean canSeekBackward() {
            return true;
        }

        public boolean canSeekForward() {
            return true;
        }
    }

    public void handleEvent(Event evt) {
        final Event event = evt;
        mHandler.post(new Runnable() {
            public void run() {
                String type = event.getType();
                if(type.equals(SmilDocumentImpl.SMIL_DOCUMENT_END_EVENT)) {
                    finish();
                }
            }
        });
    }
}