1 /*

     2 * Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  This class is native player implementation of Player interface

    15 *

    16 */

    17 

    18 

    19 package com.nokia.microedition.media;

    20 

    21 import javax.microedition.media.PlayerListener;

    22 import javax.microedition.media.MediaException;

    23 import com.nokia.microedition.media.NativeError;

    24 import com.nokia.mj.impl.rt.support.Finalizer;

    25 import com.nokia.mj.impl.utils.Logger;

    26 

    27 public class PlayerImpl extends PlayerBase

    28 {

    29     // CMMAPlayer handle

    30     protected int iPlayerHandle;

    31 

    32     // Controls container

    33     protected ControlContainer iControls;

    34 

    35     // object for waiting native asynchronous method calls

    36     protected Object iLockObject = new Object();

    37     protected Object iPrefetchLockObject = new Object();

    38 

    39     // native error code

    40     protected int iError;

    41 

    42     protected PlayerListenerImpl iPlayerListenerImpl;

    43 

    44     private Finalizer mFinalizer;

    45 

    46     private boolean iWaitFlag = true;

    47 

    48     private boolean iStartWaitFlag = true;

    49 

    50     /**

    51      * Constructor

    52      * @param aPlayerHandle handle to player (CMMAPlayer)

    53      */

    54     public PlayerImpl(int aPlayerHandle)

    55     {

    56         iPlayerHandle = aPlayerHandle;

    57 

    58         iPlayerListenerImpl = new PlayerListenerImpl(this);

    59 

    60         // Initialize player

    61         int err = _initPlayer(iPlayerListenerImpl,

    62                               ManagerImpl.getEventSource(),

    63                               iPlayerHandle);

    64         if (err < NativeError.KErrNone)

    65         {

    66             throw new OutOfMemoryError(NativeError.errorMessage(err));

    67         }

    68 

    69         mFinalizer = new Finalizer()

    70         {

    71             public void finalizeImpl()

    72             {

    73                 doFinalize();

    74             }

    75         };

    76 

    77         iControls = ControlContainer.populateControls(this,

    78                     ManagerImpl.getEventSource(),

    79                     iPlayerHandle);

    80     }

    81 

    82     private void doFinalize()

    83     {

    84         if (mFinalizer != null)

    85         {

    86             registeredFinalize();

    87             mFinalizer = null;

    88         }

    89     }

    90 

    91     /**

    92      * This method is called when garbage collection occurs

    93      * to delete native object

    94      */

    95     protected void registeredFinalize()

    96     {

    97         close();

    98     }

    99 

   100     /**

   101      * Returns native player handle.

   102      * @return Native player handle.

   103      */

   104     public int getPlayerHandle()

   105     {

   106         return iPlayerHandle;

   107     }

   108 

   109     /**

   110      * @return Player's PlayerListenerImpl

   111      */

   112     public PlayerListenerImpl getPlayerListenerImpl()

   113     {

   114         return iPlayerListenerImpl;

   115     }

   116 

   117     /**

   118      * Adds control to the player.

   119      * @param aControl Player's control

   120      * @param aControlName Identifies the control. Name must contain

   121      * full package information

   122      */

   123     public void addControl(javax.microedition.media.Control aControl,

   124                            String aControlName)

   125     {

   126         iControls.addControl(aControl, aControlName);

   127     }

   128 

   129     /**

   130      * interface Controllable

   131      * Return controls

   132      * @return list of controls

   133      * @see Controllable

   134      */

   135     public javax.microedition.media.Control[] getControls()

   136     {

   137         closeCheck();

   138         unrealizedCheck();

   139         return iControls.getControls();

   140     }

   141 

   142     /**

   143      * interface Controllable

   144      * get control by content type

   145      * @param aControlType content type of wanted control

   146      * @return control

   147      * @see Controllable

   148      * @see Control

   149      */

   150     public javax.microedition.media.Control getControl(String aControlType)

   151     {

   152         closeCheck();

   153         unrealizedCheck();

   154         return iControls.getControl(aControlType);

   155     }

   156 

   157     /**

   158      * interface Player

   159      * @see Player

   160      */

   161     public void addPlayerListener(PlayerListener aPlayerListener)

   162     {

   163         closeCheck();

   164         iPlayerListenerImpl.addPlayerListener(aPlayerListener);

   165     }

   166 

   167     /**

   168      * From Player

   169      * @see Player

   170      */

   171     public void removePlayerListener(PlayerListener aPlayerListener)

   172     {

   173         closeCheck();

   174         iPlayerListenerImpl.removePlayerListener(aPlayerListener);

   175     }

   176 

   177     /**

   178      * From Player

   179      * @see Player

   180      */

   181     public int getState()

   182     {

   183         int state = CLOSED;

   184         if (iState != CLOSED)

   185         {

   186             Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : before _getState()  ");

   187             state = _getState(ManagerImpl.getEventSource(), iPlayerHandle);

   188             Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : after _getState()  ");

   189         }

   190         Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"+ PlayerIMPl.getState() ");

   191         return state;

   192     }

   193 

   194 

   195     /**

   196      * From PlayerBase

   197      * @see PlayerBase

   198      */

   199     public void doRealize() throws MediaException

   200     {

   201         int err = _realize(ManagerImpl.getEventSource(), iPlayerHandle);

   202 

   203         if (err < NativeError.KErrNone)

   204         {

   205             throw new MediaException(

   206                 "Realize failed, Symbian OS error: " + err);

   207         }

   208     }

   209 

   210     /**

   211      * From PlayerBase

   212      * @see PlayerBase

   213      */

   214     public void doPrefetch() throws MediaException

   215     {

   216         Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : doPrefetch");

   217         synchronized (iPrefetchLockObject)

   218         {

   219             if (PREFETCHED == getState())

   220                 return;

   221             synchronized (iLockObject)

   222             {

   223                 Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : doPrefetch inside try"+Thread.currentThread().getName());

   224                 //int retval[] = new int[1];

   225                 int err = _prefetch(ManagerImpl.getEventSource(), iPlayerHandle);

   226                 Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : doPrefetch err = " + err);

   227                 if (err < NativeError.KErrNone)

   228                 {

   229                     throw new MediaException(

   230                         "Prefetch failed, Symbian OS error: " + err);

   231                 }

   232                 if (iWaitFlag)

   233                 {

   234                     try

   235                     {

   236                         // wait until actionCompleted( int aError ) is called

   237                         iLockObject.wait();

   238                     }

   239                     catch (InterruptedException ie)

   240                     {

   241                         // cannot occur

   242                     }

   243                 }

   244                 Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : doPrefetch Sync end");

   245             } // end   synchronized (iLockObject)

   246         }

   247 

   248         if (iError < NativeError.KErrNone)

   249         {

   250             throw new MediaException(

   251                 "Prefetch failed, Symbian OS error: " + iError);

   252         }

   253     }

   254 

   255     /**

   256      * Notify that action is completed. Called from native side.

   257      * @param aError error code

   258      */

   259     private void actionCompleted(int aError)

   260     {

   261         Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"actionCompleted callback11 aError ="+ aError + "    "+Thread.currentThread().getName());

   262         iError = aError;

   263 

   264         synchronized (iLockObject)

   265         {

   266             Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"actionCompleted callback inside synchronized (iLockObject)");

   267             iLockObject.notify();

   268         }

   269     }

   270 

   271     private void actionCompletedFile()

   272     {

   273         Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : actionCompletedFile");

   274         iWaitFlag = false;

   275 

   276     }

   277 

   278     private void actionCompletedStart()

   279     {

   280         Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : actionCompletedStart");

   281         iStartWaitFlag = false;

   282 

   283     }

   284 

   285     /**

   286      * From PlayerBase

   287      * @see PlayerBase

   288      */

   289     public void doDeallocate()

   290     {

   291         int ret = _deallocate(ManagerImpl.getEventSource(), iPlayerHandle);

   292         if (ret < NativeError.KErrNone)

   293         {

   294             Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,

   295                        "_deallocate() failed: err=" + ret);

   296         }

   297     }

   298 

   299     /**

   300      * From Player.

   301      * @see Player

   302      */

   303     public void start() throws MediaException

   304     {

   305         Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : start()");

   306         Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : start() outside if(iSPrefetchOngoing)");

   307         prefetch();

   308         Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl, start, state = "+getState());

   309         // Only preteched player may be started. If player is already started

   310         // this method returns silently.

   311         if (getState() == PREFETCHED)

   312         {

   313             synchronized (iLockObject)

   314             {

   315                 Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl, before calling native _start() thread is =" +Thread.currentThread().getName());

   316                 Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl, before calling native _start()");

   317                 int err = _start(ManagerImpl.getEventSource(), iPlayerHandle);

   318                 Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl, before calling native _start( ) returned : err = "+err);

   319                 if (err < NativeError.KErrNone)

   320                 {

   321                     throw new MediaException(

   322                         "Start failed, Symbian OS error: " + err);

   323                 }

   324                 if (iError < NativeError.KErrNone)

   325                 {

   326                     throw new MediaException(

   327                         "Start failed, Symbian OS error: " + iError);

   328                 }

   329                 if (iStartWaitFlag)

   330                 {

   331                     try

   332                     {

   333                         // wait until actionCompleted( int aError ) is called

   334                         iLockObject.wait();   // only for tck run

   335                     }

   336                     catch (InterruptedException ie)

   337                     {

   338                         // cannot occur

   339                     }

   340 

   341                 }

   342             }

   343         }

   344     }

   345 

   346     /**

   347      * From PlayerBase

   348      * @see PlayerBase

   349      */

   350     public void doStop() throws MediaException

   351     {

   352         /*

   353         Stops the Player. It will pause the playback at the current media time.

   354         Calling start will resume the playback from where it is stopped.

   355         If stop is called on a stopped Player, the request is ignored.

   356         */

   357         Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : doStop()");

   358         int err = _stop(ManagerImpl.getEventSource(), iPlayerHandle);

   359         if (err < NativeError.KErrNone)

   360         {

   361             throw new MediaException(

   362                 "Stop failed, Symbian OS error: " + err);

   363         }

   364         // After this request is completed,

   365         // the Player is in the PREFETCHED state.

   366     }

   367 

   368     /**

   369      * From PlayerBase

   370      * @see PlayerBase

   371      */

   372     public void doClose()

   373     {

   374         Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : doclose() 1");

   375         _close(ManagerImpl.getEventSource(), iPlayerHandle);

   376 

   377         if (iPlayerHandle > NativeError.KErrNone)  // construction has succeed

   378         {

   379             Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : doclose() 2");

   380             // notify the controls

   381             iControls.dispose();

   382             Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : doclose() 3");

   383 

   384             // delete the native object

   385             _dispose(ManagerImpl.getEventSource(), iPlayerHandle);

   386             Logger.LOG(Logger.EJavaMMAPI, Logger.EInfo,"PlayerImpl.java : doclose() 4");

   387             iPlayerHandle = 0; // Do not use native object anymore

   388         }

   389     }

   390     /**

   391      * interface Player

   392      * @see Player

   393      */

   394     public void setLoopCount(int aCount)

   395     {

   396         super.setLoopCount(aCount);

   397         _setLoopCount(ManagerImpl.getEventSource(), iPlayerHandle, aCount);

   398     }

   399 

   400     /**

   401      * interface Player

   402      * @see Player

   403      */

   404     public long getDuration()

   405     {

   406         closeCheck();

   407         long duration = _duration(ManagerImpl.getEventSource(), iPlayerHandle);

   408         if (duration < NativeError.KErrNone)

   409         {

   410             duration = TIME_UNKNOWN;

   411         }

   412         return duration;

   413     }

   414 

   415     /**

   416      * From PlayerBase

   417      * @see PlayerBase

   418      */

   419     public long setMediaTime(long aNow) throws MediaException

   420     {

   421         long time = _setMediaTime(ManagerImpl.getEventSource(),

   422                                   iPlayerHandle,

   423                                   super.setMediaTime(aNow));

   424         if (time < NativeError.KErrNone)

   425         {

   426             throw new MediaException(

   427                 "Could not set media time, Symbian OS error: " + time);

   428         }

   429         return time;

   430     }

   431 

   432     /**

   433      * interface Player

   434      * @see Player

   435      */

   436     public long getMediaTime()

   437     {

   438         closeCheck();

   439         long time = _getMediaTime(ManagerImpl.getEventSource(), iPlayerHandle);

   440         if (time < NativeError.KErrNone)

   441         {

   442             time = TIME_UNKNOWN;

   443         }

   444         return time;

   445     }

   446 

   447 

   448     /**

   449      * interface Player

   450      * @see Player

   451      */

   452     public String getContentType()

   453     {

   454         closeCheck();

   455         unrealizedCheck();

   456 

   457         return _getContentType(iPlayerHandle);

   458     }

   459 

   460     // JNI

   461     private native int _initPlayer(Object aPlayerListenerObject,

   462                                    int aEventSource,

   463                                    int aPlayerHandle);

   464 

   465     private static native int _start(int aEventPoster, int aPlayer);

   466     private static native int _stop(int aEventPoster, int aPlayer);

   467     private static native int _close(int aEventPoster, int aPlayer);

   468     private static native int _prefetch(int aEventPoster, int aPlayer);

   469 

   470     private static native int _setLoopCount(int aEventPoster, int aPlayer,

   471                                             int aLoopCount);

   472 

   473     private static native int _realize(int aEventPoster, int aPlayer);

   474     private static native long _duration(int aEventPoster, int aPlayer);

   475     private static native long _setMediaTime(int aEventPoster, int aPlayer,

   476             long aNow);

   477 

   478     private static native int _deallocate(int aEventPoster, int aPlayer);

   479     private static native long _getMediaTime(int aEventPoster, int aPlayer);

   480     private static native int _getState(int aEventPoster, int aPlayer);

   481 

   482     protected static native int _addSourceStream(int aEventPoster,

   483             int aPlayerHandle,

   484             Object aSourceStreamReader);

   485 

   486     private static native String _getContentType(int aPlayerHandle);

   487 

   488     private static native void _dispose(int aEventSourceHandle,

   489                                         int aObjectHandle);

   490 }

   491 

   492 // End of File