Develop Reference

How to set MediaRecorder orientation to landscape or portrait

How to set MediaRecorder orientation to landscape or portrait
I have been trying out the MediaRecorder class in Android
I had a look at this code
http://www.truiton.com/2015/05/capture-record-android-screen-using-mediaprojection-apis/
I want to set the orientation of the video being recorded to either portrait or Landscape
How can this be done
I Had a look at https://developer.android.com/reference/android/media/MediaRecorder.html#setOrientationHint(int)
It specifies to set the Rotation in Int, what values should we use for Landscape and Portrait Respectively

int: the angle to be rotated clockwise in degrees. The supported angles are 0, 90, 180, and 270 degrees.
You can take the refernce from the below for MediaRecorder.
You need to get the current camera orientation and then add the logic to set the orientation based on the front camera or back camera:
Below is for camera1API
Camera.CameraInfo camera_info = new Camera.CameraInfo()
int camera_orientation = camera_info.orientation;
Below is for camera2API
CameraCharacteristics characteristics;
CameraManager manager = (CameraManager)getSystemService(Context.CAMERA_SERVICE);
characteristics = manager.getCameraCharacteristics(cameraIdS);
int camera_orientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
Below is common for both camera1API and camera2API
The int camera_orientation of the camera image. The value is the angle that the camera image needs to be rotated clockwise so it shows correctly on the display in its natural orientation. It should be 0, 90, 180, or 270.
For example, suppose a device has a naturally tall screen. The back-facing camera sensor is mounted in landscape. You are looking at the screen. If the top side of the camera sensor is aligned with the right edge of the screen in natural orientation, the value should be 90. If the top side of a front-facing camera sensor is aligned with the right of the screen, the value should be 270.
private int getDeviceDefaultOrientation() {
WindowManager windowManager = (WindowManager)this.getContext().getSystemService(Context.WINDOW_SERVICE);
Configuration config = getResources().getConfiguration();
int rotation = windowManager.getDefaultDisplay().getRotation();
if( ( (rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) &&
config.orientation == Configuration.ORIENTATION_LANDSCAPE )
|| ( (rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270) &&
config.orientation == Configuration.ORIENTATION_PORTRAIT ) ) {
return Configuration.ORIENTATION_LANDSCAPE;
}
else {
return Configuration.ORIENTATION_PORTRAIT;
}
}
Set orientation to landscape
int device_orientation = getDeviceDefaultOrientation();
int result;
if (device_orientation == Configuration.ORIENTATION_PORTRAIT) {
// should be equivalent to onOrientationChanged(270)
if (camera_controller.isFrontFacing()) {
result = (camera_orientation + 90) % 360;
} else {
result = (camera_orientation + 270) % 360;
}
} else {
// should be equivalent to onOrientationChanged(0)
result = camera_orientation;
}
Set orientation to portrait
int device_orientation = getDeviceDefaultOrientation();
int result;
if (device_orientation == Configuration.ORIENTATION_PORTRAIT) {
// should be equivalent to onOrientationChanged(0)
result = camera_orientation;
} else {
// should be equivalent to onOrientationChanged(90)
if (camera_controller.isFrontFacing()) {
result = (camera_orientation + 270) % 360;
} else {
result = (camera_orientation + 90) % 360;
}
}

Android Camera Rotation Generic

Im trying to rotate my camera when the device rotates, iv tried several methods, but none of them seem to work on all devices.
//This Works on my nexus 5 but not on my Samsung galaxy tab
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height)
{
if (mHolder.getSurface() == null)
{
return;
}
try
{
mCamera.stopPreview();
Camera.Parameters parameters = mCamera.getParameters();
parameters.set("orientation", "landscape");
int rotation = ((WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getRotation();
int orientation = getContext().getResources().getConfiguration().orientation;
if (rotation == Surface.ROTATION_0) {
if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
mCamera.setDisplayOrientation(0);
} else {
mCamera.setDisplayOrientation(90);
}
}
else if (rotation == Surface.ROTATION_90) {
if (orientation == Configuration.ORIENTATION_PORTRAIT) {
mCamera.setDisplayOrientation(270);
}
}
else if (rotation == Surface.ROTATION_180) {
if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
mCamera.setDisplayOrientation(180);
}
}
else if (rotation == Surface.ROTATION_270) {
if (orientation == Configuration.ORIENTATION_PORTRAIT) {
mCamera.setDisplayOrientation(90);
}
}
mCamera.setPreviewDisplay(holder);
mCamera.startPreview();
}
catch (Exception e) {
}
}
// and i tried this, which is part of the documentation and it doesnt work on my nexus 5:
public static void setCameraDisplayOrientation(Activity activity,
int cameraId, android.hardware.Camera camera) {
android.hardware.Camera.CameraInfo info =
new android.hardware.Camera.CameraInfo();
android.hardware.Camera.getCameraInfo(cameraId, info);
int rotation = activity.getWindowManager().getDefaultDisplay()
.getRotation();
int degrees = 0;
switch (rotation) {
case Surface.ROTATION_0: degrees = 0; break;
case Surface.ROTATION_90: degrees = 90; break;
case Surface.ROTATION_180: degrees = 180; break;
case Surface.ROTATION_270: degrees = 270; break;
}
int result;
if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
result = (info.orientation + degrees) % 360;
result = (360 - result) % 360; // compensate the mirror
} else { // back-facing
result = (info.orientation - degrees + 360) % 360;
}
camera.setDisplayOrientation(result);
}
Does someone have a working solution for all devices?

Although I'm not exactly sure what's your issue from the code you provided, here are few things one has to got right when using Camera API and image rotation on Android (the old one - on API <21)
1. You have to take in account the orientation of the image sensor.
The orientation of the sensor means its angle to the device native use-mode. (that's what actually does the google snippet you are using) For phones this is usually being set to portrait, on tablets to landscape.
Here is an excerpt from the documentation, it can make pain in head for a while, but that's just how things work.
For example, suppose a device has a naturally tall screen. The back-facing camera sensor is mounted in landscape. You are looking at the screen. If the top side of the camera sensor is aligned with the right edge of the screen in natural orientation, the value should be 90. If the top side of a front-facing camera sensor is aligned with the right of the screen, the value should be 270.
2. Frontfacing camera preview is being mirrored
If you use frontfacing camera, you have to take in account the implicit mirroring.
3. These rules are only meant for rotating the Camera preview
This is important. All this is only meant to allow you to display correctly rotated preview frames on the device screen. Once you take an actual picture, you have to rotate it once again to suit your needs. For front-facing images this might mean mirroring it yourself,...You can see the result of this "weirdness" among all apps on Android. Just take picture in hangouts and share it right away. On various phones you gotta get somewhat weirdly rotated image as the result.
4. OEMs does not adhere to specs all the time
All I can say, is that probably no solution will be hasslefree, we got some issues with some particular devices. (as usual on Android:)
5. Use the CWAC Camera library
We found this library to be a superior wrapper around the official Camera APIs. Solving practically all of the issues I did mention.

android setrequestorientation lock with current orientation calls on create in some devices

Hi and thanks in advance,
I am having a weird issue with screen lock orientation. The funny thing is this problem just happen to me in ONE device, a Samsung galaxy Tab. In the others tablets and smartphones does not react like this.
The thing is, imagine that you detect your orientation and lock it with this code:
public void lockScreenOrientation() {
System.out.println("A VER Q DEVUELVE ESTO: "+((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay().getRotation());
switch (((WindowManager) getSystemService(WINDOW_SERVICE))
.getDefaultDisplay().getRotation()) {
case Surface.ROTATION_90:
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
break;
case Surface.ROTATION_180:
setRequestedOrientation(9/* reversePortait */);
break;
case Surface.ROTATION_270:
setRequestedOrientation(8/* reverseLandscape */);
break;
default :
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
}
Suppostly, i just want to tell the device to keep the current orientation, but in that tablet it calls the onCreate !! why is that? why only that device? In the others works fine
And i do not want to override onConfigurationChanged because i need to call the code in on create, where the lock code is it....so it gets in a infinite loop........
Can i solve this? or it is a problem or issue of only this device?
best regards

I found the answer. It seems the orientation codes are not the same for tablet than to smartphone, i didn't know that.
The problem is that in the tablet the orientation i was trying to set, was wrong for him !! Like it is not the same for the smartphone than to the tablet
I found this other code, that perfectly did the trick for all devices :)
DisplayMetrics displaymetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
//Con esto pilla pantalla completa
screenheight = getWindowManager().getDefaultDisplay().getHeight();
screenwidth = getWindowManager().getDefaultDisplay().getWidth();
public void lockScreenOrientation() {
Display display = getWindowManager().getDefaultDisplay();
int rotation = display.getRotation();
Point size = new Point();
//display.getSize(size);
size.x=screenwidth;
size.y=screenheight;
int lock = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
if (rotation == Surface.ROTATION_0
|| rotation == Surface.ROTATION_180) {
// if rotation is 0 or 180 and width is greater than height, we have
// a tablet
if (size.x > size.y) {
if (rotation == Surface.ROTATION_0) {
lock = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
} else {
lock = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
}
} else {
// we have a phone
if (rotation == Surface.ROTATION_0) {
lock = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
} else {
lock = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
}
}
} else {
// if rotation is 90 or 270 and width is greater than height, we
// have a phone
if (size.x > size.y) {
if (rotation == Surface.ROTATION_90) {
lock = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
} else {
lock = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
}
} else {
// we have a tablet
if (rotation == Surface.ROTATION_90) {
lock = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
} else {
lock = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
}
}
}
setRequestedOrientation(lock);
}

When orientation is changed the OS destroys the activity and rebuilds it.. that is why onCreate is called. You could just set the activity in your manifest to only allow one orientation:
<activity
android:name=".YourActivity"
android:label="#string/app_name"
android:screenOrientation="portrait" >

getDefaultDisplay().getRotation(); returns always same value

I´m trying to get the device orientation when taking a photo from a custom camera Activity.
Previously, I checked everywhere how to achieve it, and got no results to the solutions people suggest.
I´m using this line of code to retrieve the orientation with no results. It always returns 1. I´m using a Samsung Galaxy S III for developing, if it helps.
int rotation = getWindowManager().getDefaultDisplay().getRotation();
Log.d(TAG, "Taken rotation " + rotation);
DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width = dm.widthPixels;
int height = dm.heightPixels;
int orientation;
// if the device's natural orientation is portrait:
if ((rotation == Surface.ROTATION_0
|| rotation == Surface.ROTATION_180) && height > width ||
(rotation == Surface.ROTATION_90
|| rotation == Surface.ROTATION_270) && width > height) {
switch(rotation) {
case Surface.ROTATION_0:
orientation = 0;
break;
case Surface.ROTATION_90:
orientation = 90;
break;
case Surface.ROTATION_180:
orientation =180;
break;
case Surface.ROTATION_270:
orientation = 270;
break;
default:
Log.e(TAG, "Unknown screen orientation. Defaulting to " +
"portrait.");
orientation = 0;
break;
}

This is a guess based on what I know but I'm thinking Surface.ROTATION_90 is a constant integer name. Think of it like having this:
final int Surface.ROTATION_0 = 0;
final int Surface.ROTATION_90 = 1;
final int Surface.ROTATION_180 = 2;
final int Surface.ROTATION_270 = 3;
at the beginning of your program. When a precompiler sees one of these constants it automatically replaces it with the integer equivalent. When you initialize you're int rotation and set it to one of these the int holds the value that constant has been initialized at.
So, if you want to check Surface.Rotation directly you'll probably have to call getRotation() every time you check;
Something like:
Display display = getWindowManager().getDefaultDisplay();
if(display.getRotation() == Surface.ROTATION_0)
{
//whatever you need to do here
}
etc.
or you can simply check for the integers these constants evaluate as.
int rotation = getWindowManager().getDefaultDisplay().getRotation;
if(rotation == 0)
{
//whatever you need to do here
}
etc.
Personally I'd go with the second option. Not having to call getRotation for every check might mean a small improvement in the runtime but its a good habit to minimize processor use whenever possible.

How to detect the orientation of wallpaper in android

I use WallpaperManager.getDrawable() to get the current wallpaper and then convert it to bitmap to do something else. I find that sometimes I will get the wrong data of wallpaper when the device rotates continuously. For example, the width and height of wallpaper is about portrait when the device is in the landscape mode.
Does anyone know how to detect the current orientation of wallpaper or any related data about wallpaper orientation?

I realize that this answer is almost a year late, but hopefully the following provides a solution for others trying to determine the orientation of their wallpapers:
((WindowManager)
this.getApplication().getSystemService(Service.WINDOW_SERVICE)).getDefaultDisplay().getOrientation();
the above code will return an integer which is equal to Surface.ROTATION_0, Surface.ROTATION_90, Surface.ROTATION_180, or Surface.ROTATION_270.
Note: this refers to the WallpaperService.

Not sure if this helps?
How to handle screen orientation change when progress dialog and background thread active?

Here you can get the orientation given any Context:
#JvmStatic
fun isInPortraitMode(activity: Activity): Boolean {
val currentOrientation = getCurrentOrientation(activity)
return currentOrientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT || currentOrientation == ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
}
#TargetApi(Build.VERSION_CODES.HONEYCOMB_MR2)
#JvmStatic
fun getCurrentOrientation(context: Context): Int {
//code based on https://www.captechconsulting.com/blog/eric-miles/programmatically-locking-android-screen-orientation
val windowManager = context.getSystemService(Service.WINDOW_SERVICE) as WindowManager
val display = windowManager.defaultDisplay
val rotation = display.rotation
val size = Point()
display.getSize(size)
val result: Int//= ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
if (rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) {
// if rotation is 0 or 180 and width is greater than height, we have
// a tablet
if (size.x > size.y) {
if (rotation == Surface.ROTATION_0) {
result = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
} else {
result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
}
} else {
// we have a phone
if (rotation == Surface.ROTATION_0) {
result = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
} else {
result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
}
}
} else {
// if rotation is 90 or 270 and width is greater than height, we
// have a phone
if (size.x > size.y) {
if (rotation == Surface.ROTATION_90) {
result = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
} else {
result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
}
} else {
// we have a tablet
if (rotation == Surface.ROTATION_90) {
result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
} else {
result = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
}
}
}
return result
}