/**
  * For in-app messages that have a preferred orientation, locks the screen orientation and returns
  * true if the screen is currently in the preferred orientation. If the screen is not currently in
  * the preferred orientation, returns false.
  *
  * <p>Always returns true for tablets, regardless of current orientation.
  *
  * <p>Always returns true if the in-app message doesn't have a preferred orientation.
  *
  * @param inAppMessage
  * @return
  */
 boolean verifyOrientationStatus(IInAppMessage inAppMessage) {
   if (ViewUtils.isRunningOnTablet(mActivity)) {
     AppboyLogger.d(TAG, "Running on tablet. In-app message can be displayed in any orientation.");
     return true;
   }
   Orientation preferredOrientation = inAppMessage.getOrientation();
   if (preferredOrientation == null) {
     AppboyLogger.d(
         TAG, "No orientation specified. In-app message can be displayed in any orientation.");
     return true;
   }
   if (preferredOrientation == Orientation.ANY) {
     AppboyLogger.d(
         TAG, "Any orientation specified. In-app message can be displayed in any orientation.");
     return true;
   }
   int currentScreenOrientation = mActivity.getResources().getConfiguration().orientation;
   if (currentOrientationIsValid(currentScreenOrientation, preferredOrientation)) {
     if (mOriginalOrientation == null) {
       AppboyLogger.d(TAG, "Requesting orientation lock.");
       mOriginalOrientation = mActivity.getRequestedOrientation();
       mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LOCKED);
     }
     return true;
   }
   return false;
 }
Esempio n. 2
1
  @Override
  public void setPreferredOrientations(
      int deviceOrientationMask, SetPreferredOrientationsResponse callback) {
    Activity activity = ActivityImpl.getCurrentActivity();
    if (activity == null) {
      callback.call(false);
      return;
    }

    // Currently the Android implementation only supports masks with zero or one
    // selected device orientations.
    int androidOrientation;
    if (deviceOrientationMask == 0) {
      androidOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
    } else if (deviceOrientationMask == DeviceOrientation.PORTRAIT_UP) {
      androidOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
    } else if (deviceOrientationMask == DeviceOrientation.LANDSCAPE_LEFT) {
      androidOrientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
    } else if (deviceOrientationMask == DeviceOrientation.PORTRAIT_DOWN) {
      androidOrientation = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
    } else if (deviceOrientationMask == DeviceOrientation.LANDSCAPE_RIGHT) {
      androidOrientation = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
    } else {
      callback.call(false);
      return;
    }

    activity.setRequestedOrientation(androidOrientation);
    callback.call(true);
  }
Esempio n. 3
1
  //  @TargetApi(5)
  // TODO find out why the above is not working and I need to use SupressLint to get rid of the
  // error
  @SuppressLint("newApi")
  public void disableRotation() {
    switch (activity.getResources().getConfiguration().orientation) {
      case Configuration.ORIENTATION_PORTRAIT:
        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.FROYO) {
          activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        } else {
          int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
          if (rotation == android.view.Surface.ROTATION_90
              || rotation == android.view.Surface.ROTATION_180) {
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT);
          } else {
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
          }
        }
        break;

      case Configuration.ORIENTATION_LANDSCAPE:
        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.FROYO) {
          activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        } else {
          int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
          if (rotation == android.view.Surface.ROTATION_0
              || rotation == android.view.Surface.ROTATION_90) {
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
          } else {
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
          }
        }
        break;
    } // switch
  }
 public static void setActivityOrientation(Activity activity, int orientationFromConfiguration) {
   if (orientationFromConfiguration == Configuration.ORIENTATION_LANDSCAPE) {
     if (Build.VERSION.SDK_INT < 9) {
       if (activity.getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
         // You need to check if your desired orientation isn't
         // already set because setting orientation restarts your
         // Activity which takes long
         activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
       }
     } else {
       if (activity.getRequestedOrientation()
           != ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE) {
         // You need to check if your desired orientation isn't
         // already set because setting orientation restarts your
         // Activity which takes long
         activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
       }
     }
   } else if (orientationFromConfiguration == Configuration.ORIENTATION_PORTRAIT) {
     if (Build.VERSION.SDK_INT < 9) {
       if (activity.getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
         activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
       }
     } else {
       if (activity.getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT) {
         activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);
       }
     }
   } else {
     if (activity.getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_USER) {
       activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_USER);
     }
   }
 }
Esempio n. 5
0
 public static void lockOrientation(Activity context) {
   int currentOrientation = context.getResources().getConfiguration().orientation;
   if (currentOrientation == Configuration.ORIENTATION_LANDSCAPE) {
     context.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
   } else {
     context.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);
   }
 }
 public static void setPortrait(Context context) {
   mIsNeedSensor = true;
   if (context != null) {
     if (android.os.Build.VERSION.SDK_INT >= 9
         && !VDVideoFullModeController.getInstance().getIsScreenLock()) {
       ((Activity) context)
           .setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);
     } else {
       ((Activity) context).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
     }
   }
 }
 @Override
 public void onToggleFullScreen() {
   if (!mInFS) {
     if (!mIsLargeScreen)
       mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
     openFullscreen();
   } else {
     if (!mIsLargeScreen)
       mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
     closeFullscreen();
   }
 }
 @Test
 public void getAndSetRequestedOrientation_shouldDelegateToParentIfPresent() throws Exception {
   Activity parentActivity = new Activity() {};
   Activity activity = new Activity() {};
   shadowOf(activity).setParent(parentActivity);
   parentActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
   assertEquals(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT, activity.getRequestedOrientation());
   activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
   assertEquals(
       ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE,
       parentActivity.getRequestedOrientation());
 }
 public static void setNoSensor(Context context) {
   mIsNeedSensor = false;
   if (context != null) {
     DisplayMetrics metrics = new DisplayMetrics();
     ((Activity) context).getWindowManager().getDefaultDisplay().getMetrics(metrics);
     int w = metrics.widthPixels;
     int h = metrics.heightPixels;
     if (w > h) {
       ((Activity) context).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
     } else {
       ((Activity) context).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
     }
   }
 }
 @Test
 public void shouldSetOrientation() {
   activity = create(DialogLifeCycleActivity.class);
   activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
   assertThat(activity.getRequestedOrientation())
       .isEqualTo(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
 }
 public static void setOnlyLandscape(Context context) {
   mIsNeedSensor = false;
   if (context != null) {
     if (android.os.Build.VERSION.SDK_INT >= 9) {
       ((Activity) context)
           .setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
     }
   }
 }
 public void resetAfterInAppMessageClose() {
   mInAppMessageViewWrapper = null;
   mDisplayingInAppMessage.set(false);
   if (mActivity != null && mOriginalOrientation != null) {
     mActivity.setRequestedOrientation(mOriginalOrientation);
     AppboyLogger.d(
         TAG, "Setting requested orientation to original orientation " + mOriginalOrientation);
     mOriginalOrientation = null;
   }
 }
 public void onCreate() {
   activity.setRequestedOrientation(
       orientationStrategyProvider.getOrientationStrategy().getAppropriateOrientation());
   if (androidDevice.isDebuggable()) {
     ViewServer.get(activity).addWindow(activity);
   }
   wasInAccessibilityMode = accessibilityUtil.isAccessibilityEnabled();
   getTalkDelegate();
   speechDelegate = new SpeechDelegate(activity);
   talkDelegate.ignoreAnnounceTitleOnce();
 }
Esempio n. 14
0
  // 静态方法 锁定屏幕
  public static int lockScreenOrientation(Activity mActivity) {
    Configuration config = mActivity.getResources().getConfiguration();

    int mHardwareRotation = SystemProperties.getInt("ro.sf.hwrotation", 0);

    Log.v(
        "",
        ">>>>>>>>>>>> config orientation : "
            + config.orientation
            + " , mHardwareRotation : "
            + mHardwareRotation);

    switch (mHardwareRotation) {
      case 0:
        mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        break;
      case 90:
        mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        break;
        // case 180:
        //	 mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT);
        //	break;
        // case 270:
        //	 mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
        //	break;
      default:
        mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        break;
    }

    /*
    if (config.orientation == Configuration.ORIENTATION_LANDSCAPE) {
              Log.d(TAG, ">>>>>>>>>> lock orientation to landscape");
              mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
          } else {
              Log.d(TAG, ">>>>>>>>>> lock orientation to portrait");
              mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
          }*/

    return mHardwareRotation;
  }
Esempio n. 15
0
 public void toggleOrientation() {
   if (getContext() instanceof Activity && mOrientation != ORIENTATION_LOCKED) {
     Activity mActivity = (Activity) getContext();
     if (isLandscape()) {
       mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);
     } else {
       mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
     }
     if (mOrientation == ORIENTATION_SENSOR) {
       getHandler()
           .postDelayed(
               new Runnable() {
                 @Override
                 public void run() {
                   setOrientation(mOrientation);
                 }
               },
               2000);
     }
   }
 }
Esempio n. 16
0
 @Override
 public void onHideCustomView() {
   if (mCustomView == null) return;
   setFullscreen(false);
   FrameLayout decor = (FrameLayout) mActivity.getWindow().getDecorView();
   decor.removeView(mFullscreenContainer);
   mFullscreenContainer = null;
   mCustomView = null;
   mCustomViewCallback.onCustomViewHidden();
   // Show the content view.
   mActivity.setRequestedOrientation(mOriginalOrientation);
 }
Esempio n. 17
0
 public void setOrientation(int orientation) {
   if (getContext() instanceof Activity) {
     Activity mActivity = (Activity) getContext();
     switch (orientation) {
       case ORIENTATION_PORTRAIT:
         mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
         break;
       case ORIENTATION_LANDSCAPE:
         mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
         break;
       case ORIENTATION_SENSOR_LANDSCAPE:
         mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
         break;
       case ORIENTATION_SENSOR_PORTRAIT:
         mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);
         break;
       case ORIENTATION_SENSOR:
         mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
         break;
       case ORIENTATION_LOCKED:
         mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LOCKED);
         break;
     }
     mOrientation = orientation;
     invalidate();
   }
 }
Esempio n. 18
0
    protected static void a(Activity activity, b b1)
    {
        int i = activity.getResources().getConfiguration().orientation;
        static final class _cls1
        {

            static final int a[];

            static 
            {
                a = new int[b.values().length];
                try
                {
                    a[b.c.ordinal()] = 1;
                }
                catch (NoSuchFieldError nosuchfielderror2) { }
                try
                {
                    a[com.appnexus.opensdk.b.b.ordinal()] = 2;
                }
                catch (NoSuchFieldError nosuchfielderror1) { }
                try
                {
                    a[b.a.ordinal()] = 3;
                }
                catch (NoSuchFieldError nosuchfielderror)
                {
                    return;
                }
            }
        }

        _cls1.a[b1.ordinal()];
        JVM INSTR tableswitch 1 3: default 44
    //                   1 50
    //                   2 56
    //                   3 61;
           goto _L1 _L2 _L3 _L4
_L1:
        b(activity, i);
        return;
_L2:
        activity.setRequestedOrientation(-1);
        return;
_L3:
        i = 2;
        continue; /* Loop/switch isn't completed */
_L4:
        i = 1;
        if (true) goto _L1; else goto _L5
Esempio n. 19
0
  public void show() {
    PackageInfo versionInfo = getPackageInfo();
    final String eulaKey = EULA_PREFIX + versionInfo.versionCode;
    final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext);

    boolean bAlreadyAccepted = prefs.getBoolean(eulaKey, false);
    if (bAlreadyAccepted == false) {
      String title = mContext.getString(R.string.app_name) + "  " + versionInfo.versionName;
      String message = mContext.getString(R.string.eula_string);
      mContext.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

      AlertDialog.Builder builder =
          new AlertDialog.Builder(mContext)
              .setTitle(title)
              .setMessage(message)
              .setCancelable(false)
              .setPositiveButton(
                  R.string.accept,
                  new Dialog.OnClickListener() {

                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                      // Mark this version as read.
                      SharedPreferences.Editor editor = prefs.edit();
                      editor.putBoolean(eulaKey, true);
                      editor.commit();

                      // Close dialog
                      dialogInterface.dismiss();

                      // Enable orientation changes based on
                      // device's sensor
                      mContext.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
                    }
                  })
              .setNegativeButton(
                  android.R.string.cancel,
                  new Dialog.OnClickListener() {

                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                      // Close the activity as they have declined
                      // the EULA
                      mContext.finish();
                      mContext.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
                    }
                  });
      builder.create().show();
    }
  }
Esempio n. 20
0
 /* returns true when the calling app is responsible for monitoring */
 public static boolean setOrientation(Activity activity) {
   SharedPreferences options = PreferenceManager.getDefaultSharedPreferences(activity);
   int orientation = Integer.parseInt(options.getString(PREF_ORIENTATION, "0"));
   switch (orientation) {
     case 0:
       activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
       break;
     case 1:
       activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
       break;
     case 2:
       activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
       break;
     case 3:
       activity.setRequestedOrientation(
           options.getInt(
               Options.PREF_PREV_ORIENTATION, ActivityInfo.SCREEN_ORIENTATION_PORTRAIT));
       return true;
     default:
       break;
   }
   return false;
 }
Esempio n. 21
0
  @Override
  public void showCustomView(
      View view, int requestedOrientation, WebChromeClient.CustomViewCallback callback) {
    // if a view already exists then immediately terminate the new one
    if (mCustomView != null) {
      callback.onCustomViewHidden();
      return;
    }

    mOriginalOrientation = mActivity.getRequestedOrientation();
    FrameLayout decor = (FrameLayout) mActivity.getWindow().getDecorView();
    mFullscreenContainer = new FullscreenHolder(mActivity);
    mFullscreenContainer.addView(view, COVER_SCREEN_PARAMS);
    decor.addView(mFullscreenContainer, COVER_SCREEN_PARAMS);
    mCustomView = view;
    setFullscreen(true);
    mCustomViewCallback = callback;
    mActivity.setRequestedOrientation(requestedOrientation);
  }
  @Before
  public void setUp() {
    ShadowApplication.setDisplayMetricsDensity(1.0f);

    activity = spy(Robolectric.buildActivity(Activity.class).create().get());
    activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

    rootView = new FrameLayout(activity);
    when(mockBridge.isVisible()).thenReturn(true);

    // By default, immediately fulfill a screen metrics wait request. Individual tests can
    // reset this, if desired.
    when(mockScreenMetricsWaiter.waitFor(Mockito.<View>anyVararg())).thenReturn(mockWaitRequest);
    doAnswer(
            new Answer<Void>() {
              @Override
              public Void answer(final InvocationOnMock invocation) throws Throwable {
                Runnable runnable = (Runnable) invocation.getArguments()[0];
                runnable.run();
                return null;
              }
            })
        .when(mockWaitRequest)
        .start(any(Runnable.class));

    subject =
        new MraidController(
            activity,
            mockAdReport,
            PlacementType.INLINE,
            mockBridge,
            mockTwoPartBridge,
            mockScreenMetricsWaiter);
    subject.setMraidListener(mockMraidListener);
    subject.setOrientationBroadcastReceiver(mockOrientationBroadcastReceiver);
    subject.setRootView(rootView);
    subject.loadContent("fake_html_data");

    verify(mockBridge).setMraidBridgeListener(bridgeListenerCaptor.capture());
    verify(mockTwoPartBridge).setMraidBridgeListener(twoPartBridgeListenerCaptor.capture());
  }
 public static void lockOrientationLandscape(Activity activity) {
   activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
 }
Esempio n. 24
0
 public static void setActivityOrientation(Activity activity) {
   if (shouldSetOrientation()) {
     activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
     Log.d(LOG_TAG, "setOrientationPortait Activity:" + activity);
   }
 }
Esempio n. 25
0
 /**
  * dynamically enable rotation counterpart to enableRotation slightly modified from
  * http://stackoverflow.com/a/8765901/322642
  */
 public void enableRotation() {
   activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
 }
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    super.requestWindowFeature(Window.FEATURE_NO_TITLE); // 设置无标题窗口
    super.getWindow()
        .setFlags(
            WindowManager.LayoutParams.FLAG_FULLSCREEN,
            WindowManager.LayoutParams.FLAG_FULLSCREEN); // 全屏模式
    super.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); // 强制为横屏
    this.setContentView(R.layout.yooxicafe_goodslist);
    Intent intent = this.getIntent();
    String goodsid = intent.getStringExtra("goodsid");
    Cursor c = dbhelper.queryByParamgoodsid(dbhelper.GOODS_TM_NAME, goodsid);
    try {
      goodslists = jmGoodsListAction.getGoodsListSQLiteNoZip(c);
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    c.close();
    if (!goodslists.isEmpty()) {
      holder.setGoodsimage((ImageView) this.findViewById(R.id.goodsimage));
      holder.setGoodsname((TextView) this.findViewById(R.id.goodsname));
      holder.setWeight((TextView) this.findViewById(R.id.valueweight));
      holder.setUnitname((TextView) this.findViewById(R.id.unitname));
      holder.setMemberprice((TextView) this.findViewById(R.id.memberprice));
      holder.setDetail((TextView) this.findViewById(R.id.goodsdetail));

      holder.getGoodsimage().setImageBitmap((Bitmap) goodslists.get(0).get("pictureurl"));
      holder.getGoodsname().setText(goodslists.get(0).get("goodsname").toString());
      holder.getMemberprice().setText(goodslists.get(0).get("memberprice").toString());
      holder.getUnitname().setText(goodslists.get(0).get("unitname").toString());
      holder.getWeight().setText(goodslists.get(0).get("weight").toString());
    }

    // 处理返回事件响应
    getback = (TextView) this.findViewById(R.id.getback);
    getback.setOnClickListener(
        new OnClickListener() {
          @Override
          public void onClick(View v) {
            finish();
          }
        });

    // 处理加入餐车事件
    countplus = (TextView) this.findViewById(R.id.countplus);
    countplus.setOnClickListener(
        new OnClickListener() {
          @Override
          public void onClick(View v) {
            addtoCart(goodslists, 0);
          }
        });

    // 查看已选
    checkselected = (TextView) this.findViewById(R.id.checkselected);
    checkselected.setOnClickListener(
        new OnClickListener() {
          @Override
          public void onClick(View v) {
            setElecartListView();
          }
        });
  }
 @Test
 public void getAndSetRequestedOrientation_shouldRemember() throws Exception {
   Activity activity = new Activity() {};
   activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
   assertEquals(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT, activity.getRequestedOrientation());
 }
 public static void setSensor(Context context) {
   mIsNeedSensor = true;
   if (context != null) {
     ((Activity) context).setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
   }
 }
Esempio n. 29
0
 public static void unlockOrientation(Activity context) {
   context.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
 }
Esempio n. 30
0
 /**
  * 设置activity屏幕为垂直方向。
  *
  * @param activity Activity对象。
  */
 public static void setScreenPortrait(Activity activity) {
   activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
 }