Is that possible to check was onCreate called because of orientation change?

Question

I need to act differently in onStart() method depending on how onCreate() was called in result of orientation change or not. Is that possible to check it?

Actually what I need is to do something when activity starts except a case when user changes orientation.

I need to clearly distinguish cases when user just switched to another application and returned back OR he changed device's orientation.

Answer 1

Following Nahtan's idea I wrote this:

in onCreate():

if ( (oldConfigInt & ActivityInfo.CONFIG_ORIENTATION)==ActivityInfo.CONFIG_ORIENTATION ) {
    // ... was rotated
} else {
    // ... was not rotated
}

in onDestroy():

super.onDestroy();
oldConfigInt = getChangingConfigurations();

Answer 2

public class MyActivity extends Activity {
    boolean fromOrientation=false;
    SharedPreferences myPrefLogin;
    Editor prefsEditor;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        prefsEditor = myPrefLogin.edit();
        myPrefLogin = this.getSharedPreferences("myPrefs", Context.MODE_WORLD_READABLE);
        fromOrientation = myPrefLogin.getString("fromOrient", false);

        if(fromOrientation) {
             // do as per need--- logic of orientation changed.
        } else {
             // do as per need--- logic of default onCreate().
        }
    }

    @Override
    public Object onRetainNonConfigurationInstance() {
        prefsEditor.putString("fromOrient", true);
        prefsEditor.commit();
        return null;
    }

    @Override
    protected void onDestroy() {
        if(fromOrientation) {
            prefsEditor.putString("fromOrient", false);
            prefsEditor.commit();
        }
        super.onDestroy();
    }  
}

flag fromOrientation(tells the state either configuration had been change or not) above we had done like by defalut we are considering that onCreate() is not called from by changing orientation. If orientation changed(onRetainNonConfigurationInstance()) then we set the flag value in preference which let us know whether onCreate() is called from on orientation or not. And finally onDestroy() we again reset the orientation flag.

Answer 3

Just check the bundle: when the activity is first started the bundle will be null. If there is an orientation change, it should be non-null.

From the android docs:

If the activity is being re-initialized after previously being shut down then this Bundle contains the data it most recently supplied in onSaveInstanceState(Bundle). Note: Otherwise it is null.

Edit: I don't think you have to supply a bundle in onSaveInstanceState for it to be non-null after an orientation change, but that would be trivial.

Answer 4

Try getChangingConfigurations. Use this to discover when the activity is being destroyed because of an orientation change, set a flag, and check that flag when onCreate is called.

This has the advantage of letting you know why the activity is restarting without overriding orientation configuration in the manifest.

Answer 5

As others have said, save the state:

public class MyActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        if(savedInstanceState == null) {
            // app started afresh, don't check orientation
            /* do application first-run stuff */
        } else {
            // re-started, so check for orientation change
            boolean orientationChanged = false;
            if(savedInstanceState != null) {
                int lastOrientation = savedInstanceState.getInt("last_orientation");
                orientationChanged = (getOrientation() != lastOrientation);
            }

            if(orientationChanged) {
                // orientation changed
                /* do stuff */
            } else {
                // orientation has not changed
                /* do stuff */
            }
        }
    }

    @Override
    public void onSaveInstanceState(Bundle savedInstanceState) {
        super.onSaveInstanceState(savedInstanceState);
        savedInstanceState.putInt("last_orientation", getOrientation());
    }

    private int getOrientation() {
        // ...
    }
}

Answer 6

You can try the following. On each onStart, you can save the current orientation (take a look here). If it is the first onStart call, do nothing, on other calls, check if the orientation has changed and do what you need.

private int m_currentOrientation = -1;

public void onStart()
{
   int oldOrientation = m_currentOrientation; // 
   m_currentOrientation = getCurrentOrientation(); // As in the link above
   if ((oldOrientation != -1) && (oldOrientation != m_currentOrientation))
   {
       // Do what you need
   }
}

Answer 7

In that case, why don't you handle configuration chanages (orientation) by yourself. Tell android not to handle screen orientation.

android:configChanges="keyboardHidden|orientation"

Then you just override onConfigurationChanged method to get your rearranging of view or whatsoever things need to be done. Leave things that you don't wanna get executed.

@Override
public void onConfigurationChanged(Configuration newConfig) {
  super.onConfigurationChanged(newConfig);
  //do your jobs 
}

Answer 8

The mCurrentOrientation will be -1 if the app is starting for the first time.

static int mCurrentOrientation = -1;

public void onStart()
{
   int oldOrientation = mCurrentOrientation; 
   mCurrentOrientation = getCurrentOrientation(); 
   if ((oldOrientation != -1) && (oldOrientation != mCurrentOrientation)) {
       // Do your something here.
   }
}

If I understood your question correctly, I think this should work for you.