Example usage for android.content.pm ActivityInfo SCREEN_ORIENTATION_SENSOR

List of usage examples for android.content.pm ActivityInfo SCREEN_ORIENTATION_SENSOR

Introduction

In this page you can find the example usage for android.content.pm ActivityInfo SCREEN_ORIENTATION_SENSOR.

Prototype

int SCREEN_ORIENTATION_SENSOR

To view the source code for android.content.pm ActivityInfo SCREEN_ORIENTATION_SENSOR.

Click Source Link

Document

Constant corresponding to sensor in the android.R.attr#screenOrientation attribute.

Usage

From source file:org.puder.trs80.EmulatorActivity.java

private void unlockScreenOrientation() {
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
}

From source file:cz.tomsuch.lampicka.activities.LampActivity.java

/**
 * Sums whole process of disconnecting onPause, on manual disconnect, ...
 * *//* w ww.  ja va 2  s  . c om*/
private void disconnect() {
    setLampIsConnected(false);
    handler.postAtFrontOfQueue(new Runnable() {

        @Override
        public void run() {
            try {
                handler.removeCallbacksAndMessages(null);
            } catch (Throwable t) {
                t.printStackTrace();
            }
            if (isReceiverRegistered) {
                unregisterReceiver(uuidsReceiver);
                isReceiverRegistered = false;
            }
            try {
                if (socket != null)
                    socket.close();
                socket = null;
            } catch (Throwable t) {
                t.printStackTrace();
            }
        }
    });
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
}

From source file:com.youku.player.plugin.MediaPlayerDelegate.java

public void clearEnd() {
    if (null != videoInfo && (StaticsUtil.PLAY_TYPE_LOCAL.equals(videoInfo.playType) || videoInfo.isHLS))
        return;/*from   www. ja  v a  2s  . com*/
    if (null == context)
        return;
    if (!PlayerUtil.isYoukuTablet(context))
        context.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
}

From source file:com.fsm.storybook.launcher.WebViewActivity.java

private void unlockScreenRotation() {
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
}

From source file:com.xmobileapp.rockplayer.RockPlayer.java

/*******************************************
 * /*from  w  w w  .ja  v a  2  s  .  co  m*/
 * OnActivityResult
 * 
 *******************************************/
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    try {
        Log.i("BACKFROMPREFERENCES", "Activity Result Processing...");

        /*
         * Coming back from preferences - check if stuff changed
         */
        if (requestCode == new Constants().PREFERENCES_REQUEST) {
            Log.i("BACKFROMPREFERENCES", "...From Preferences Activity...");

            RockOnPreferenceManager settings = new RockOnPreferenceManager(FILEX_PREFERENCES_PATH);
            /*
             * Check for the recently added playlist period change
             */
            //            if(this.recentPlaylistPeriod != getSharedPreferences(PREFS_NAME, 0)
            if (this.recentPlaylistPeriod != settings.getInt(new Constants().PREF_KEY_RECENT_PERIOD,
                    new Constants().RECENT_PERIOD_DEFAULT_IN_DAYS)) {

                Log.i("BACKFROMPREFERENCES", "Recent Playlist Period was changed...");

                //                this.recentPlaylistPeriod = getSharedPreferences(PREFS_NAME, 0)
                this.recentPlaylistPeriod = settings.getInt(new Constants().PREF_KEY_RECENT_PERIOD,
                        new Constants().RECENT_PERIOD_DEFAULT_IN_DAYS);

                /*
                 * Update value of the service component
                 */
                this.playerServiceIface.setRecentPeriod(this.recentPlaylistPeriod);

                /*
                 * Update the UI if we are playing the recently added playlist
                 */
                if (this.playlist == new Constants().PLAYLIST_RECENT) {
                    Log.i("BACKFROMPREFERENCES", "Reloading album navigator");
                    /*
                     * Reinitialize the album and song cursors
                     */
                    initializeAlbumCursor();
                    albumCursor.moveToFirst();
                    songCursor = initializeSongCursor(albumCursor
                            .getString(albumCursor.getColumnIndexOrThrow(MediaStore.Audio.Albums.ALBUM)));

                    /*
                     * Reload Navigator List
                     */
                    recycleNavigatorList();
                    albumAdapter = null;
                    getAlbums(true);
                }
            }

            /*
             * Reload preferences that require modification
             */
            readPreferences();
            albumAdapter.showArtWhileScrolling = showArtWhileScrolling;
            albumAdapter.showFrame = showFrame;

            /*
             * Reload Orientation stuff
             */
            if (alwaysLandscape)
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
            else if (autoRotate)
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
            else
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);

            /*
             * Update background
             */
            if (VIEW_STATE == NORMAL_VIEW)
                setBackground();
        }
    } catch (Exception e) {

    }

}

From source file:com.youku.player.base.YoukuBasePlayerActivity.java

private void initMediaPlayer() { //---------->
    //      mediaPlayerDelegate.mediaPlayer = BaseMediaPlayer.getInstance();
    mediaPlayerDelegate.mediaPlayer = RemoteInterface.baseMediaPlayer;
    mediaPlayerDelegate.mediaPlayer.setOnBufferingUpdateListener(new OnBufferingUpdateListener() {

        @Override//from   ww  w.  j  av a2  s .co  m
        public void onBufferingUpdate(MediaPlayer mp, int percent) {
            if (onPause) {
                mp.release();
                return;
            }
            if (pluginManager == null)
                return;
            pluginManager.onBufferingUpdateListener(percent);
        }
    });
    mediaPlayerDelegate.mediaPlayer.setOnCompletionListener(new OnCompletionListener() {

        @Override
        public void onCompletion(MediaPlayer mp) {
            if (mediaPlayerDelegate != null)
                mediaPlayerDelegate.onComplete();
            if (mYoukuPlayerView != null)
                mYoukuPlayerView.setPlayerBlack();
        }
    });
    mediaPlayerDelegate.mediaPlayer.setOnErrorListener(new OnErrorListener() {

        @Override
        public boolean onError(MediaPlayer mp, int what, int extra) {
            Logger.d("PlayFlow", " MediaPlayer onError what=" + what + " !!!");
            if (mYoukuPlayerView != null)
                mYoukuPlayerView.setDebugText("-->onError:" + what);
            disposeAdErrorLoss(what);
            if (isAdPlayError(what)) {
                Logger.d("PlayFlow", ":" + what + " ?:");
                return loadingADOverTime();
            }
            if (mediaPlayerDelegate != null && !mYoukuPlayerView.realVideoStart) {
                runOnUiThread(new Runnable() {
                    public void run() {
                        detectPlugin();
                    }
                });
            }
            if (!isSendPlayBreakEvent && MediaPlayerConfiguration.getInstance().trackPlayError()
                    && mYoukuPlayerView.realVideoStart && mediaPlayerDelegate != null
                    && mediaPlayerDelegate.videoInfo != null) {
                final String videoUrl = mediaPlayerDelegate.videoInfo.getWeburl();
                final TaskSendPlayBreak task = new TaskSendPlayBreak(videoUrl);
                task.execute();
                isSendPlayBreakEvent = true;
            }
            if (mYoukuPlayerView.realVideoStart && mediaPlayerDelegate.isLoading)
                Track.onPlayLoadingEnd();
            onLoadingFailError();
            if (pluginManager == null) {
                Logger.d("PlayFlow", "onError:" + what + " pluginManager == null  return false");
                return false;
            }
            //Logger.d("PlayFlow", ":" + what + " ?:??);"
            int nowPostition = mediaPlayerDelegate.getCurrentPosition();
            if (nowPostition > 0) {
                position = nowPostition;
            }
            // ?
            if (what == -38 && !MediaPlayerProxyUtil.isUplayerSupported()) {
                what = MPPErrorCode.MEDIA_INFO_PLAY_UNKNOW_ERROR;
            }
            return pluginManager.onError(what, extra);
        }

        private boolean isAdPlayError(int what) {
            return what == MPPErrorCode.MEDIA_INFO_PREPARED_AD_CHECK
                    || (what == MPPErrorCode.MEDIA_INFO_DATA_SOURCE_ERROR
                            && !mediaPlayerDelegate.isAdvShowFinished())
                    || (what == MPPErrorCode.MEDIA_INFO_NETWORK_ERROR && mediaPlayerDelegate.isADShowing)
                    || (what == MPPErrorCode.MEDIA_INFO_NETWORK_CHECK && mediaPlayerDelegate.isADShowing);
        }

        //??
        private void disposeAdErrorLoss(int what) {
            if (mediaPlayerDelegate == null || mediaPlayerDelegate.videoInfo == null) {
                return;
            }
            if (what == MPPErrorCode.MEDIA_INFO_DATA_SOURCE_ERROR
                    && !mediaPlayerDelegate.videoInfo.isAdvEmpty()) {
                DisposableStatsUtils.disposeAdLoss(YoukuBasePlayerActivity.this, URLContainer.AD_LOSS_STEP4,
                        SessionUnitil.playEvent_session, URLContainer.AD_LOSS_MF);
            }
            if (what == MPPErrorCode.MEDIA_INFO_PREPARED_AD_CHECK) {
                DisposableStatsUtils.disposeAdLoss(YoukuBasePlayerActivity.this, URLContainer.AD_LOSS_STEP6,
                        SessionUnitil.playEvent_session, URLContainer.AD_LOSS_MF);
            }
        }
    });

    mediaPlayerDelegate.mediaPlayer.setOnPreparedListener(new OnPreparedListener() {

        @Override
        public void onPrepared(MediaPlayer mp) {
            if (pluginManager == null)
                return;
            pluginManager.onPrepared();
        }
    });

    mediaPlayerDelegate.mediaPlayer.setOnSeekCompleteListener(new OnSeekCompleteListener() {

        @Override
        public void onSeekComplete(MediaPlayer mp) {
            if (mediaPlayerDelegate != null) {
                mediaPlayerDelegate.isLoading = false;
            }
            Track.setTrackPlayLoading(true);
            if (pluginManager == null)
                return;
            runOnUiThread(new Runnable() {
                public void run() {
                    pluginManager.onSeekComplete();
                }
            });
        }
    });
    mediaPlayerDelegate.mediaPlayer.setOnVideoSizeChangedListener(new OnVideoSizeChangedListener() {

        @Override
        public void onVideoSizeChanged(MediaPlayer mp, int width, int height) {
            if (pluginManager == null)
                return;
            pluginManager.onVideoSizeChanged(width, height);
            Logger.e(TAG, "onVideoSizeChanged-->" + width + height);
            mediaPlayerDelegate.mediaPlayer.updateWidthAndHeight(width, height);

        }
    });
    mediaPlayerDelegate.mediaPlayer.setOnTimeOutListener(new OnTimeoutListener() {

        @Override
        public void onTimeOut() {
            if (mediaPlayerDelegate == null)
                return;
            Logger.d("PlayFlow", "onTimeOut");
            mediaPlayerDelegate.release();
            runOnUiThread(new Runnable() {

                @Override
                public void run() {
                    Track.pause();
                    onLoadingFailError();
                }
            });
            if (!isSendPlayBreakEvent && MediaPlayerConfiguration.getInstance().trackPlayError()
                    && mYoukuPlayerView.realVideoStart && mediaPlayerDelegate != null
                    && mediaPlayerDelegate.videoInfo != null) {
                final String videoUrl = mediaPlayerDelegate.videoInfo.getWeburl();
                final TaskSendPlayBreak task = new TaskSendPlayBreak(videoUrl);
                task.execute();
                isSendPlayBreakEvent = true;
            }
            runOnUiThread(new Runnable() {
                public void run() {
                    if (pluginManager == null)
                        return;
                    pluginManager.onTimeout();
                }
            });
        }

        @Override
        public void onNotifyChangeVideoQuality() {
            if (pluginManager == null)
                return;
            Logger.d("PlayFlow", "onNotifyChangeVideoQuality");
            pluginManager.onNotifyChangeVideoQuality();
        }
    });
    mediaPlayerDelegate.mediaPlayer.setOnCurrentPositionUpdateListener(new OnCurrentPositionUpdateListener() {

        @Override
        public void onCurrentPositionUpdate(final int currentPosition) {
            if (pluginManager == null)
                return;
            runOnUiThread(new Runnable() {

                @Override
                public void run() {
                    try {
                        pluginManager.onCurrentPositionChange(currentPosition);
                    } catch (Exception e) {
                    }
                }
            });
        }
    });

    if (PlayerUtil.useUplayer()) {
        mediaPlayerDelegate.mediaPlayer.setOnADPlayListener(new OnADPlayListener() {

            @Override
            public boolean onStartPlayAD(int index) {
                Logger.d("PlayFlow", "onstartPlayAD");
                Track.onAdStart();
                String vid = "";
                if (mediaPlayerDelegate != null && mediaPlayerDelegate.videoInfo != null)
                    vid = mediaPlayerDelegate.videoInfo.getVid();
                Track.trackAdLoad(getApplicationContext(), vid);
                mYoukuPlayerView.setPlayerBlackGone();
                mPluginADPlay.setInteractiveAdVisible(false);
                if (mediaPlayerDelegate != null) {
                    mediaPlayerDelegate.isADShowing = true;
                    mediaPlayerDelegate.isAdStartSended = true;
                    if (mediaPlayerDelegate.videoInfo != null
                            && mediaPlayerDelegate.videoInfo.videoAdvInfo != null) {
                        if (mediaPlayerDelegate.videoInfo.videoAdvInfo.SKIP != null
                                && mediaPlayerDelegate.videoInfo.videoAdvInfo.SKIP.equals("1")) {
                            if (null != mPluginADPlay) {
                                mPluginADPlay.setSkipVisible(true);
                            }
                        }
                        if (mediaPlayerDelegate.videoInfo.videoAdvInfo.VAL.get(0).RST.equals("hvideo")) {
                            if (mPluginADPlay.isInteractiveAdShow()) {
                                mPluginADPlay.setInteractiveAdVisible(true);
                            } else {
                                String brs = mediaPlayerDelegate.videoInfo.videoAdvInfo.VAL.get(0).BRS;
                                int count = mediaPlayerDelegate.videoInfo.videoAdvInfo.VAL.get(0).AL;
                                mPluginADPlay.startInteractiveAd(brs, count);
                                mPluginADPlay.showInteractiveAd();
                            }
                        }
                    }
                }

                updatePlugin(PLUGIN_SHOW_AD_PLAY);
                if (null != pluginManager) {
                    runOnUiThread(new Runnable() {
                        public void run() {
                            pluginManager.onLoaded();
                            if (null != mPluginADPlay) {
                                mPluginADPlay.setVisible(true);
                            }
                        }
                    });
                }
                if (mediaPlayerDelegate != null && mediaPlayerDelegate.videoInfo != null) {
                    AnalyticsWrapper.adPlayStart(getApplicationContext(), mediaPlayerDelegate.videoInfo);
                }
                try {
                    DisposableStatsUtils.disposeSUS(mediaPlayerDelegate.videoInfo);
                } catch (NullPointerException e) {
                    Logger.e("sgh", e.toString());
                }

                if (mediaPlayerDelegate.videoInfo.getCurrentAdvInfo() != null
                        && (mediaPlayerDelegate.videoInfo.getCurrentAdvInfo().VSC == null
                                || mediaPlayerDelegate.videoInfo.getCurrentAdvInfo().VSC
                                        .equalsIgnoreCase(""))) {
                    DisposableStatsUtils.disposeVC(mediaPlayerDelegate.videoInfo);
                }

                return false;
            }

            @Override
            public boolean onEndPlayAD(int index) {
                Logger.d("PlayFlow", "onEndPlayAD");

                if (mediaPlayerDelegate != null) {
                    mediaPlayerDelegate.isADShowing = false;
                }
                Track.onAdEnd();

                if (mediaPlayerDelegate != null && mediaPlayerDelegate.videoInfo != null) {
                    AnalyticsWrapper.adPlayEnd(getApplicationContext(), mediaPlayerDelegate.videoInfo);
                }
                // removePlayedAdv?
                DisposableStatsUtils.disposeSUE(mediaPlayerDelegate.videoInfo);
                // ????
                mediaPlayerDelegate.videoInfo.removePlayedAdv();
                if (mediaPlayerDelegate.videoInfo.isCached()) {
                    ICacheInfo download = IMediaPlayerDelegate.mICacheInfo;
                    if (download != null) {
                        if (download.isDownloadFinished(mediaPlayerDelegate.videoInfo.getVid())) {
                            VideoCacheInfo downloadInfo = download
                                    .getDownloadInfo(mediaPlayerDelegate.videoInfo.getVid());
                            if (YoukuBasePlayerActivity.isHighEnd) {
                                mediaPlayerDelegate.videoInfo.cachePath = PlayerUtil
                                        .getM3u8File(downloadInfo.savePath + "youku.m3u8");
                            }
                        }
                    }
                }
                if (null != pluginManager) {
                    runOnUiThread(new Runnable() {
                        public void run() {
                            mPluginADPlay.closeInteractiveAdNotIcludeUI();
                            pluginManager.onLoading();
                        }
                    });
                }
                Logger.e(TAG, "onEndPlayAD");
                return false;
            }
        });
        mediaPlayerDelegate.mediaPlayer.setOnADCountListener(new OnADCountListener() {

            @Override
            public void onCountUpdate(final int count) {

                position = mediaPlayerDelegate.getCurrentPosition();
                final int currentPosition = mediaPlayerDelegate.getCurrentPosition() / 1000;
                runOnUiThread(new Runnable() {
                    public void run() {
                        mPluginADPlay.notifyUpdate(count);
                        mYoukuPlayerView.resizeMediaPlayer(false);

                        DisposableStatsUtils.disposeSU(mediaPlayerDelegate.videoInfo, currentPosition);
                    }
                });

            }
        });
        mediaPlayerDelegate.mediaPlayer.setOnNetworkSpeedListener(new OnNetworkSpeedListener() {

            @Override
            public void onSpeedUpdate(final int count) {
                if (null != pluginManager) {
                    runOnUiThread(new Runnable() {
                        public void run() {
                            pluginManager.onNetSpeedChange(count);
                        }
                    });
                }
            }
        });
    }
    mediaPlayerDelegate.mediaPlayer.setOnRealVideoStartListener(new OnRealVideoStartListener() {

        @Override
        public void onRealVideoStart() {
            if (onPause)
                return;
            // listener??
            // mediaPlayerDelegate
            Logger.d("PlayFlow", "");
            Track.isRealVideoStarted = true;
            String vid = "";
            if (mediaPlayerDelegate != null && mediaPlayerDelegate.videoInfo != null)
                vid = mediaPlayerDelegate.videoInfo.getVid();
            Track.onRealVideoFirstLoadEnd(getApplicationContext(), vid);
            localStartSetDuration();
            sentonVVBegin();
            mYoukuPlayerView.setPlayerBlackGone();
            if (mediaPlayerDelegate != null && mediaPlayerDelegate.videoInfo != null) {
                mediaPlayerDelegate.isADShowing = false;
                Logger.e(TAG, "onRealVideoStart" + mediaPlayerDelegate.videoInfo.IsSendVV);
            } else {
                Logger.e(TAG, "onRealVideoStart mediaPlayerDelegate");
            }
            mediaPlayerDelegate.isLoading = false;
            if (null != pluginManager) {
                runOnUiThread(new Runnable() {
                    public void run() {
                        detectPlugin();
                        pluginManager.onRealVideoStart();
                        pluginManager.onLoaded();
                    }
                });
            }

            if (mediaPlayerDelegate != null) {
                if (mediaPlayerDelegate.videoInfo != null && mediaPlayerDelegate.videoInfo.getProgress() > 1000
                        && !mediaPlayerDelegate.videoInfo.isHLS) {
                    mediaPlayerDelegate.seekTo(mediaPlayerDelegate.videoInfo.getProgress());
                    Logger.e("PlayFlow", "SEEK TO" + mediaPlayerDelegate.videoInfo.getProgress());
                }
            }
            runOnUiThread(new Runnable() {
                public void run() {
                    if (mInvestigate != null) {
                        mInvestigate.show();
                    }
                }
            });
        }
    });
    mediaPlayerDelegate.mediaPlayer.setOnLoadingStatusListener(new OnLoadingStatusListener() {

        @Override
        public void onStartLoading() {
            Logger.e(TAG, "onStartLoading");
            if (pluginManager == null || onPause)
                return;
            Track.onPlayLoadingStart(mediaPlayerDelegate.mediaPlayer.getCurrentPosition());
            if (mediaPlayerDelegate != null) {
                mediaPlayerDelegate.isLoading = true;
            }
            runOnUiThread(new Runnable() {

                @Override
                public void run() {
                    if (pluginManager == null)
                        return;
                    pluginManager.onLoading();
                    if (PlayerUtil.useUplayer() && !mediaPlayerDelegate.videoInfo.isUseCachePath())
                        mediaPlayerDelegate.loadingPause();
                }

            });
        }

        @Override
        public void onEndLoading() {

            runOnUiThread(new Runnable() {

                @Override
                public void run() {
                    if (pluginManager == null)
                        return;
                    pluginManager.onLoaded();
                }
            });
            Track.onPlayLoadingEnd();
            if (null != mediaPlayerDelegate) {
                mediaPlayerDelegate.isStartPlay = true;
                mediaPlayerDelegate.isLoading = false;
                if (null != mediaPlayerDelegate.videoInfo) {
                    id = mediaPlayerDelegate.videoInfo.getVid();
                    mediaPlayerDelegate.videoInfo.isFirstLoaded = true;
                }
                // mp4??
                if (PlayerUtil.useUplayer() && !mediaPlayerDelegate.videoInfo.isUseCachePath())
                    mediaPlayerDelegate.start();
            }

            if (!firstLoaded && !isFromLocal() && !PreferenceUtil
                    .getPreferenceBoolean(YoukuBasePlayerActivity.this, "video_lock", false)) {
                if (mediaPlayerDelegate != null && !mediaPlayerDelegate.isFullScreen
                        && mediaPlayerDelegate.videoInfo != null
                        && StaticsUtil.PLAY_TYPE_LOCAL.equals(mediaPlayerDelegate.videoInfo.getPlayType())
                        || !PlayerUtil.isYoukuTablet(YoukuBasePlayerActivity.this)) {
                    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
                }
                Logger.d("lelouch",
                        "onLoaded setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);");
                firstLoaded = true;
            }

        }
    });
    mediaPlayerDelegate.mediaPlayer.setOnPlayHeartListener(new OnPlayHeartListener() {

        @Override
        public void onPlayHeart() {
            if (mediaPlayerDelegate != null && mediaPlayerDelegate.videoInfo != null)
                Track.trackPlayHeart(getApplicationContext(), mediaPlayerDelegate.videoInfo,
                        mediaPlayerDelegate.isFullScreen);
        }
    });
    mediaPlayerDelegate.mediaPlayer.setOnVideoIndexUpdateListener(new OnVideoIndexUpdateListener() {

        @Override
        public void onVideoIndexUpdate(int currentIndex, int ip) {
            Logger.d("PlayFlow", "onVideoIndexUpdate:" + currentIndex + "  " + ip);
            if (mediaPlayerDelegate != null && mediaPlayerDelegate.videoInfo != null)
                Track.onVideoIndexUpdate(getApplicationContext(), currentIndex, ip,
                        mediaPlayerDelegate.videoInfo.getCurrentQuality());
        }
    });
    mediaPlayerDelegate.mediaPlayer.setOnHwDecodeErrorListener(new OnHwDecodeErrorListener() {

        @Override
        public void OnHwDecodeError() {
            Logger.d("PlayFlow", "OnHwDecodeError");
            //                  DisposableHttpTask task = new DisposableHttpTask(
            //                        URLContainer.getHwErrorUrl());
            //                  task.setRequestMethod(DisposableHttpTask.METHOD_POST);
            //                  task.start();
            MediaPlayerConfiguration.getInstance().setUseHardwareDecode(false);
        }
    });
}

From source file:com.google.appinventor.components.runtime.Form.java

/**
 * The requested screen orientation. Commonly used values are
    unspecified (-1), landscape (0), portrait (1), sensor (4), and user (2).  " +
    "See the Android developer documentation for ActivityInfo.Screen_Orientation for the " +
    "complete list of possible settings.
 *
 * ScreenOrientation property getter method.
 *
 * @return  screen orientation//from w w  w  .  j ava2 s.com
 */
@SimpleProperty(category = PropertyCategory.APPEARANCE, description = "The requested screen orientation, specified as a text value.  "
        + "Commonly used values are " + "landscape, portrait, sensor, user and unspecified.  "
        + "See the Android developer documentation for ActivityInfo.Screen_Orientation for the "
        + "complete list of possible settings.")
public String ScreenOrientation() {
    switch (getRequestedOrientation()) {
    case ActivityInfo.SCREEN_ORIENTATION_BEHIND:
        return "behind";
    case ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE:
        return "landscape";
    case ActivityInfo.SCREEN_ORIENTATION_NOSENSOR:
        return "nosensor";
    case ActivityInfo.SCREEN_ORIENTATION_PORTRAIT:
        return "portrait";
    case ActivityInfo.SCREEN_ORIENTATION_SENSOR:
        return "sensor";
    case ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED:
        return "unspecified";
    case ActivityInfo.SCREEN_ORIENTATION_USER:
        return "user";
    case 10: // ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
        return "fullSensor";
    case 8: // ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
        return "reverseLandscape";
    case 9: // ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
        return "reversePortrait";
    case 6: // ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
        return "sensorLandscape";
    case 7: // ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
        return "sensorPortrait";
    }

    return "unspecified";
}

From source file:im.getsocial.testapp.MainActivity.java

private void loadDefaultUi() {
    getSocialUiConfiguration = null;
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
    GetSocial.getConfiguration().clear();
}

From source file:com.google.appinventor.components.runtime.Form.java

/**
 * ScreenOrientation property setter method: sets the screen orientation for
 * the form./*from www. j a  va 2  s  .c om*/
 *
 * @param screenOrientation  the screen orientation as a string
 */
@DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_SCREEN_ORIENTATION, defaultValue = "unspecified")
@SimpleProperty(category = PropertyCategory.APPEARANCE)
public void ScreenOrientation(String screenOrientation) {
    if (screenOrientation.equalsIgnoreCase("behind")) {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_BEHIND);
    } else if (screenOrientation.equalsIgnoreCase("landscape")) {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
    } else if (screenOrientation.equalsIgnoreCase("nosensor")) {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR);
    } else if (screenOrientation.equalsIgnoreCase("portrait")) {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    } else if (screenOrientation.equalsIgnoreCase("sensor")) {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
    } else if (screenOrientation.equalsIgnoreCase("unspecified")) {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
    } else if (screenOrientation.equalsIgnoreCase("user")) {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_USER);
    } else if (SdkLevel.getLevel() >= SdkLevel.LEVEL_GINGERBREAD) {
        if (screenOrientation.equalsIgnoreCase("fullSensor")) {
            setRequestedOrientation(10); // ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
        } else if (screenOrientation.equalsIgnoreCase("reverseLandscape")) {
            setRequestedOrientation(8); // ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
        } else if (screenOrientation.equalsIgnoreCase("reversePortrait")) {
            setRequestedOrientation(9); // ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
        } else if (screenOrientation.equalsIgnoreCase("sensorLandscape")) {
            setRequestedOrientation(6); // ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
        } else if (screenOrientation.equalsIgnoreCase("sensorPortrait")) {
            setRequestedOrientation(7); // ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
        } else {
            dispatchErrorOccurredEvent(this, "ScreenOrientation",
                    ErrorMessages.ERROR_INVALID_SCREEN_ORIENTATION, screenOrientation);
        }
    } else {
        dispatchErrorOccurredEvent(this, "ScreenOrientation", ErrorMessages.ERROR_INVALID_SCREEN_ORIENTATION,
                screenOrientation);
    }
}

From source file:org.videolan.vlc.gui.video.VideoPlayerActivity.java

/**
 * Lock screen rotation//w w w.  j av a  2 s  .c o  m
 */
private void lockScreen() {
    if (mScreenOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR)
        setRequestedOrientation(getScreenOrientation());
    showInfo(R.string.locked, 1000);
    mLock.setBackgroundResource(R.drawable.screen_lock_on);
    mTime.setEnabled(false);
    mSeekbar.setEnabled(false);
    mLength.setEnabled(false);
    hideOverlay(true);
}