I updated Nexus 5X to Android N, and now when I install the app (debug or release) on it I am getting TransactionTooLargeException on every screen transition that has Bundle in extras. The app is working on all other devices. The old app that is on PlayStore and has mostly same code is working on Nexus 5X.
Is anyone having the same issue?
java.lang.RuntimeException: android.os.TransactionTooLargeException: data parcel size 592196 bytes
at android.app.ActivityThread$StopInfo.run(ActivityThread.java:3752)
at android.os.Handler.handleCallback(Handler.java:751)
at android.os.Handler.dispatchMessage(Handler.java:95)
at android.os.Looper.loop(Looper.java:154)
at android.app.ActivityThread.main(ActivityThread.java:6077)
at java.lang.reflect.Method.invoke(Native Method)
at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:865)
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:755)
Caused by: android.os.TransactionTooLargeException: data parcel size 592196 bytes
at android.os.BinderProxy.transactNative(Native Method)
at android.os.BinderProxy.transact(Binder.java:615)
at android.app.ActivityManagerProxy.activityStopped(ActivityManagerNative.java:3606)
at android.app.ActivityThread$StopInfo.run(ActivityThread.java:3744)
at android.os.Handler.handleCallback(Handler.java:751)
at android.os.Handler.dispatchMessage(Handler.java:95)
at android.os.Looper.loop(Looper.java:154)
at android.app.ActivityThread.main(ActivityThread.java:6077)
at java.lang.reflect.Method.invoke(Native Method)
at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:865)
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:755)
Whenever you see TransactionTooLargeException happening when an Activity is in the process of stopping, that means that the Activity was trying to send its saved state Bundles to the system OS for safe keeping for restoration later (after a config change or process death) but that one or more of the Bundles it sent were too large. There is a maximum limit of about 1MB for all such transactions occurring at once and that limit can be reached even if no single Bundle exceeds that limit.
The main culprit here is generally saving too much data inside onSaveInstanceState of either the Activity or any Fragments hosted by the Activity. Typically this happens when saving something particularly large like a Bitmap but it can also happen when sending large quantities of smaller data, like lists of Parcelable objects. The Android team has made very clear on numerous occasions that only small amounts of view-related data should be saved in onSavedInstanceState. However, developers have often saved pages of network data in order to make configuration changes appear as smooth as possible by not having to refetch the same data again. As of Google I/O 2017, the Android team has made clear that the preferred architecture for an Android app saves networking data
in memory so it can be easily reused across configuration changes
to disk so that it can be easily restored after process death and app sessions
Their new ViewModel framework and Room persistence library are meant to help developers fit this pattern. If your problem is with saving too much data in onSaveInstanceState, updating to an architecture like this using those tools should fix your problem.
Personally, before updating to that new pattern I'd like to take my existing apps and just get around the TransactionTooLargeException in the meantime. I wrote a quick library to do just that: https://github.com/livefront/bridge . It uses the same general ideas of restoring state from memory across configuration changes and from disk after process death, rather than sending all that state to the OS via onSaveInstanceState, but requires very minimal changes to your existing code to use. Any strategy that fits those two goals should help you avoid the exception, though, without sacrificing your ability to save state.
On final note here : the only reason you see this on Nougat+ is that originally if the binder transaction limit was exceeded, the process to send the saved state to the OS would fail silently with only this error showing up in Logcat:
!!! FAILED BINDER TRANSACTION !!!
In Nougat, that silent failure was upgraded to a hard crash. To their credit, this is something the development team documented in the release notes for Nougat:
Many platform APIs have now started checking for large payloads being sent across Binder transactions, and the system now rethrows TransactionTooLargeExceptions as RuntimeExceptions, instead of silently logging or suppressing them. One common example is storing too much data in Activity.onSaveInstanceState(), which causes ActivityThread.StopInfo to throw a RuntimeException when your app targets Android 7.0.
In the end, my problem was with things that were being saved onSaveInstance, and not with things that were being sent to the next activity. I removed all saves where I can't control the size of objects (network responses), and now it's working.
Update 2:
Google now provides AndroidX ViewModel which is based on the same technology as retained Fragments but much easier to use. Now ViewModel is a preferred approach.
Update 1:
To preserve big chunks of data, Google is suggesting to do it with Fragment that retains instance. Idea is to create an empty Fragment without a view with all necessary fields, that would otherwise be saved in the Bundle. Add setRetainInstance(true); to Fragment's onCreate method.
And then save data in Fragment on Activity's onDestroy and load them onCreate.
Here is an example of Activity:
public class MyActivity extends Activity {
private DataFragment dataFragment;
#Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
// find the retained fragment on activity restarts
FragmentManager fm = getFragmentManager();
dataFragment = (DataFragment) fm.findFragmentByTag(“data”);
// create the fragment and data the first time
if (dataFragment == null) {
// add the fragment
dataFragment = new DataFragment();
fm.beginTransaction().add(dataFragment, “data”).commit();
// load the data from the web
dataFragment.setData(loadMyData());
}
// the data is available in dataFragment.getData()
...
}
#Override
public void onDestroy() {
super.onDestroy();
// store the data in the fragment
dataFragment.setData(collectMyLoadedData());
}
}
An example of Fragment:
public class DataFragment extends Fragment {
// data object we want to retain
private MyDataObject data;
// this method is only called once for this fragment
#Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// retain this fragment
setRetainInstance(true);
}
public void setData(MyDataObject data) {
this.data = data;
}
public MyDataObject getData() {
return data;
}
}
More about it, you can read here.
Did a hit and trial, and finally this solved my issue.
Add this to your Activity
#Override
protected void onSaveInstanceState(Bundle oldInstanceState) {
super.onSaveInstanceState(oldInstanceState);
oldInstanceState.clear();
}
The TransactionTooLargeException has been plaguing us for about 4 months now, and we've finally resolved the issue!
What was happening was we are using a FragmentStatePagerAdapter in a ViewPager. The user would page through and create 100+ fragments (its a reading application).
Although we manage the fragments properly in destroyItem(), in Androids
implementation of FragmentStatePagerAdapter there is a bug, where it kept a reference to the following list:
private ArrayList<Fragment.SavedState> mSavedState = new ArrayList<Fragment.SavedState>();
And when the Android's FragmentStatePagerAdapter attempts to save the state, it will call the function
#Override
public Parcelable saveState() {
Bundle state = null;
if (mSavedState.size() > 0) {
state = new Bundle();
Fragment.SavedState[] fss = new Fragment.SavedState[mSavedState.size()];
mSavedState.toArray(fss);
state.putParcelableArray("states", fss);
}
for (int i=0; i<mFragments.size(); i++) {
Fragment f = mFragments.get(i);
if (f != null && f.isAdded()) {
if (state == null) {
state = new Bundle();
}
String key = "f" + i;
mFragmentManager.putFragment(state, key, f);
}
}
return state;
}
As you can see, even if you properly manage the fragments in the FragmentStatePagerAdapter subclass, the base class will still store an Fragment.SavedState for every single fragment ever created. The TransactionTooLargeException would occur when that array was dumped to a parcelableArray and the OS wouldn't like it 100+ items.
Therefore the fix for us was to override the saveState() method and not store anything for "states".
#Override
public Parcelable saveState() {
Bundle bundle = (Bundle) super.saveState();
bundle.putParcelableArray("states", null); // Never maintain any states from the base class, just null it out
return bundle;
}
I face this issue as well on my Nougat devices. My app uses a fragment with a view pager which contains 4 fragments. I passed some large construction arguments to the 4 fragments which caused the problem.
I traced the size of Bundle causing this with the help of TooLargeTool.
Finally, I resolved it using putSerializable on a POJO object which implements Serializable instead of passing a large raw String using putString during fragment initialization. This reduced size of Bundle by half and does not throw the TransactionTooLargeException. Therefore, please make sure you do not pass huge size arguments to Fragment.
P.S. related issue in Google issue tracker: https://issuetracker.google.com/issues/37103380
I face the similar issue. The issue and scenario are little different and I fix it in the following way. Please check the scenario and solution.
Scenario:
I got a weird bug from the customer in the Google Nexus 6P device(7 OS) as my application will crash after 4 hours of working. Later I identify that it's throwing the similar (android.os.TransactionTooLargeException:) exception.
Solution:
The log was not pointing any particular class in the application and later I found that this is happening because of keeping the back stack of fragments. In my case, 4 fragments are added to the back stack repeatedly with the help of an auto screen movement animation. So I override the onBackstackChanged() as mention below.
#Override
public void onBackStackChanged() {
try {
int count = mFragmentMngr.getBackStackEntryCount();
if (count > 0) {
if (count > 30) {
mFragmentMngr.popBackStack(1, FragmentManager.POP_BACK_STACK_INCLUSIVE);
count = mFragmentMngr.getBackStackEntryCount();
}
FragmentManager.BackStackEntry entry = mFragmentMngr.getBackStackEntryAt(count - 1);
mCurrentlyLoadedFragment = Integer.parseInt(entry.getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
If the stack exceeds the limit, it will automatically pop to initial fragment. I hope somebody will help this answer because the exception and stack trace logs are same. So whenever this issue happens, please check the back stack count, if you are using Fragments and back stack.
In my case, I got that exception inside a fragment because one of its arguments was a very large string that I forgot to delete it (I only used that large string inside the onViewCreated() method). So, to solve this, i simply deleted that argument. In your case, you have to clear or nullify any suspicious field before call onPause().
Activity code
Fragment fragment = new Fragment();
Bundle args = new Bundle();
args.putString("extremely large string", data.getValue());
fragment.setArguments(args);
Fragment code
#Override
public void onViewCreated(View view, Bundle savedInstanceState) {
String largeString = arguments.get("extremely large string");
//Do Something with the large string
arguments.clear() //I forgot to execute this
}
The problem in my app was that I was trying to save too much into the savedInstanceState, the solution was to identify exactly which data should be saved at the right time. Basically look carefully into your onSaveInstanceState to make sure you don't stretch it:
#Override
public void onSaveInstanceState(Bundle savedInstanceState) {
// Save the user's current state
// Check carefully what you're adding into the savedInstanceState before saving it
super.onSaveInstanceState(savedInstanceState);
}
I faced the same issue.
My workaround offloads savedInstanceState to files in cache dir.
I made the following utility class.
package net.cattaka.android.snippets.issue;
import android.content.Context;
import android.content.SharedPreferences;
import android.os.Build;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
/**
* To parry BUG of Android N. https://code.google.com/p/android/issues/detail?id=212316
* <p>
* Created by cattaka on 2017/01/12.
*/
public class Issue212316Parrier {
public static final String DEFAULT_NAME = "Issue212316Parrier";
private static final String KEY_STORED_BUNDLE_ID = "net.cattaka.android.snippets.issue.Issue212316Parrier.KEY_STORED_BUNDLE_ID";
private String mName;
private Context mContext;
private String mAppVersionName;
private int mAppVersionCode;
private SharedPreferences mPreferences;
private File mDirForStoredBundle;
public Issue212316Parrier(Context context, String appVersionName, int appVersionCode) {
this(context, appVersionName, appVersionCode, DEFAULT_NAME);
}
public Issue212316Parrier(Context context, String appVersionName, int appVersionCode, String name) {
mName = name;
mContext = context;
mAppVersionName = appVersionName;
mAppVersionCode = appVersionCode;
}
public void initialize() {
mPreferences = mContext.getSharedPreferences(mName, Context.MODE_PRIVATE);
File cacheDir = mContext.getCacheDir();
mDirForStoredBundle = new File(cacheDir, mName);
if (!mDirForStoredBundle.exists()) {
mDirForStoredBundle.mkdirs();
}
long lastStoredBundleId = 1;
boolean needReset = true;
String fingerPrint = (Build.FINGERPRINT != null) ? Build.FINGERPRINT : "";
needReset = !fingerPrint.equals(mPreferences.getString("deviceFingerprint", null))
|| !mAppVersionName.equals(mPreferences.getString("appVersionName", null))
|| (mAppVersionCode != mPreferences.getInt("appVersionCode", 0));
lastStoredBundleId = mPreferences.getLong("lastStoredBundleId", 1);
if (needReset) {
clearDirForStoredBundle();
mPreferences.edit()
.putString("deviceFingerprint", Build.FINGERPRINT)
.putString("appVersionName", mAppVersionName)
.putInt("appVersionCode", mAppVersionCode)
.putLong("lastStoredBundleId", lastStoredBundleId)
.apply();
}
}
/**
* Call this from {#link android.app.Activity#onCreate(Bundle)}, {#link android.app.Activity#onRestoreInstanceState(Bundle)} or {#link android.app.Activity#onPostCreate(Bundle)}
*/
public void restoreSaveInstanceState(#Nullable Bundle savedInstanceState, boolean deleteStoredBundle) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
if (savedInstanceState != null && savedInstanceState.containsKey(KEY_STORED_BUNDLE_ID)) {
long storedBundleId = savedInstanceState.getLong(KEY_STORED_BUNDLE_ID);
File storedBundleFile = new File(mDirForStoredBundle, storedBundleId + ".bin");
Bundle storedBundle = loadBundle(storedBundleFile);
if (storedBundle != null) {
savedInstanceState.putAll(storedBundle);
}
if (deleteStoredBundle && storedBundleFile.exists()) {
storedBundleFile.delete();
}
}
}
}
/**
* Call this from {#link android.app.Activity#onSaveInstanceState(Bundle)}
*/
public void saveInstanceState(Bundle outState) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
if (outState != null) {
long nextStoredBundleId = mPreferences.getLong("lastStoredBundleId", 1) + 1;
mPreferences.edit().putLong("lastStoredBundleId", nextStoredBundleId).apply();
File storedBundleFile = new File(mDirForStoredBundle, nextStoredBundleId + ".bin");
saveBundle(outState, storedBundleFile);
outState.clear();
outState.putLong(KEY_STORED_BUNDLE_ID, nextStoredBundleId);
}
}
}
private void saveBundle(#NonNull Bundle bundle, #NonNull File storedBundleFile) {
byte[] blob = marshall(bundle);
OutputStream out = null;
try {
out = new GZIPOutputStream(new FileOutputStream(storedBundleFile));
out.write(blob);
out.flush();
out.close();
} catch (IOException e) {
// ignore
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
// ignore
}
}
}
}
#Nullable
private Bundle loadBundle(File storedBundleFile) {
byte[] blob = null;
InputStream in = null;
try {
in = new GZIPInputStream(new FileInputStream(storedBundleFile));
ByteArrayOutputStream bout = new ByteArrayOutputStream();
int n;
byte[] buffer = new byte[1024];
while ((n = in.read(buffer)) > -1) {
bout.write(buffer, 0, n); // Don't allow any extra bytes to creep in, final write
}
bout.close();
blob = bout.toByteArray();
} catch (IOException e) {
// ignore
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
// ignore
}
}
}
try {
return (blob != null) ? (Bundle) unmarshall(blob) : null;
} catch (Exception e) {
return null;
}
}
private void clearDirForStoredBundle() {
for (File file : mDirForStoredBundle.listFiles()) {
if (file.isFile() && file.getName().endsWith(".bin")) {
file.delete();
}
}
}
#NonNull
private static <T extends Parcelable> byte[] marshall(#NonNull final T object) {
Parcel p1 = Parcel.obtain();
p1.writeValue(object);
byte[] data = p1.marshall();
p1.recycle();
return data;
}
#SuppressWarnings("unchecked")
#NonNull
private static <T extends Parcelable> T unmarshall(#NonNull byte[] bytes) {
Parcel p2 = Parcel.obtain();
p2.unmarshall(bytes, 0, bytes.length);
p2.setDataPosition(0);
T result = (T) p2.readValue(Issue212316Parrier.class.getClassLoader());
p2.recycle();
return result;
}
}
Full codes: https://github.com/cattaka/AndroidSnippets/pull/37
I worry about that Parcel#marshall should not be used for persistent.
But, I don't have any other idea.
None of the above answers worked for me, the reason of the issue was quite simple as stated by some I was using FragmentStatePagerAdapter and its saveState method saves the state of the fragments, because one of my fragment was quite large , so saving of this fragment leads to this TransactionTooLargeExecption.
I tried overriding the saveState method in my implementation of pager as stated by #IK828, but this couldn't resolve the crash.
My fragment was having an EditText which used to hold very large text, which was the culprit of the issue in my case, so simply in onPause() of fragment, I set the edittext text to empty string.
ie:
#Override
public void onPause() {
edittext.setText("");
}
Now when FragmentStatePagerAdapter will try to saveState, this large chunk of text will not be there to consume bigger part of it, hence resolves the crash.
In your case you need to find whatever is the culprit, it could be an ImageView with some bitmap, a TextView with huge chunk of text or any other high memory consuming view, you need to free it's memory, you may set imageview.setImageResource(null) or similar in onPause() of your fragment.
update : onSaveInstanceState is better place for the purpose before calling super like:
#Override
public void onSaveInstanceState(Bundle outState) {
edittext.setText("");
super.onSaveInstanceState(outState);
}
or as pointed by #Vladimir you can use android:saveEnabled="false" or view.setSaveEnabled(false); on the view or custom view and make sure to set the text back in onResume otherwise it will be empty when Activity resumes.
In my case, I used TooLargeTool to track where the issue was coming from and I found out the android:support:fragments key in the Bundle from my onSaveInstanceState used to reach almost 1mb when the app crashed. So the solution was like:
#Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.remove("android:support:fragments");
}
By doing that, I avoided to save all fragments' states and kept with other things that need to be saved.
Just Override this method on your activity :
#Override
protected void onSaveInstanceState(Bundle outState) {
// below line to be commented to prevent crash on nougat.
// http://blog.sqisland.com/2016/09/transactiontoolargeexception-crashes-nougat.html
//
//super.onSaveInstanceState(outState);
}
Go to https://code.google.com/p/android/issues/detail?id=212316#makechanges for more info.
As the Android N change the behavior and throw TransactionTooLargeException instead of logging the error.
try {
if (DEBUG_MEMORY_TRIM) Slog.v(TAG, "Reporting activity stopped: " + activity);
ActivityManagerNative.getDefault().activityStopped(
activity.token, state, persistentState, description);
} catch (RemoteException ex) {
if (ex instanceof TransactionTooLargeException
&& activity.packageInfo.getTargetSdkVersion() < Build.VERSION_CODES.N) {
Log.e(TAG, "App sent too much data in instance state, so it was ignored", ex);
return;
}
throw ex.rethrowFromSystemServer();
}
my solution is to hook the ActivityMangerProxy instance and try catch the activityStopped method.
Here is the code:
private boolean hookActivityManagerNative() {
try {
ClassLoader loader = ClassLoader.getSystemClassLoader();
Field singletonField = ReflectUtils.findField(loader.loadClass("android.app.ActivityManagerNative"), "gDefault");
ReflectUtils.ReflectObject singletonObjWrap = ReflectUtils.wrap(singletonField.get(null));
Object realActivityManager = singletonObjWrap.getChildField("mInstance").get();
Object fakeActivityManager = Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
new Class[]{loader.loadClass("android.app.IActivityManager")}, new ActivityManagerHook(realActivityManager));
singletonObjWrap.setChildField("mInstance", fakeActivityManager);
return true;
} catch (Throwable e) {
AppHolder.getThirdPartUtils().markException(e);
return false;
}
}
private static class ActivityManagerHook implements InvocationHandler {
private Object origin;
ActivityManagerHook(Object origin) {
this.origin = origin;
}
public Object getOrigin() {
return origin;
}
#Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
switch (method.getName()) {
//ActivityManagerNative.getDefault().activityStopped(activity.token, state, persistentState, description);
case "activityStopped": {
try {
return method.invoke(getOrigin(), args);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
return method.invoke(getOrigin(), args);
}
}
And the reflect helper class is
public class ReflectUtils {
private static final HashMap<String, Field> fieldCache = new HashMap<>();
private static final HashMap<String, Method> methodCache = new HashMap<>();
public static Field findField(Class<?> clazz, String fieldName) throws Throwable {
String fullFieldName = clazz.getName() + '#' + fieldName;
if (fieldCache.containsKey(fullFieldName)) {
Field field = fieldCache.get(fullFieldName);
if (field == null)
throw new NoSuchFieldError(fullFieldName);
return field;
}
try {
Field field = findFieldRecursiveImpl(clazz, fieldName);
field.setAccessible(true);
fieldCache.put(fullFieldName, field);
return field;
} catch (NoSuchFieldException e) {
fieldCache.put(fullFieldName, null);
throw new NoSuchFieldError(fullFieldName);
}
}
private static Field findFieldRecursiveImpl(Class<?> clazz, String fieldName) throws NoSuchFieldException {
try {
return clazz.getDeclaredField(fieldName);
} catch (NoSuchFieldException e) {
while (true) {
clazz = clazz.getSuperclass();
if (clazz == null || clazz.equals(Object.class))
break;
try {
return clazz.getDeclaredField(fieldName);
} catch (NoSuchFieldException ignored) {
}
}
throw e;
}
}
public static Method findMethodExact(Class<?> clazz, String methodName, Class<?>... parameterTypes) throws Throwable {
String fullMethodName = clazz.getName() + '#' + methodName + getParametersString(parameterTypes) + "#exact";
if (methodCache.containsKey(fullMethodName)) {
Method method = methodCache.get(fullMethodName);
if (method == null)
throw new NoSuchMethodError(fullMethodName);
return method;
}
try {
Method method = clazz.getDeclaredMethod(methodName, parameterTypes);
method.setAccessible(true);
methodCache.put(fullMethodName, method);
return method;
} catch (NoSuchMethodException e) {
methodCache.put(fullMethodName, null);
throw new NoSuchMethodError(fullMethodName);
}
}
/**
* Returns an array of the given classes.
*/
public static Class<?>[] getClassesAsArray(Class<?>... clazzes) {
return clazzes;
}
private static String getParametersString(Class<?>... clazzes) {
StringBuilder sb = new StringBuilder("(");
boolean first = true;
for (Class<?> clazz : clazzes) {
if (first)
first = false;
else
sb.append(",");
if (clazz != null)
sb.append(clazz.getCanonicalName());
else
sb.append("null");
}
sb.append(")");
return sb.toString();
}
/**
* Retrieve classes from an array, where each element might either be a Class
* already, or a String with the full class name.
*/
private static Class<?>[] getParameterClasses(ClassLoader classLoader, Object[] parameterTypes) throws ClassNotFoundException {
Class<?>[] parameterClasses = null;
for (int i = parameterTypes.length - 1; i >= 0; i--) {
Object type = parameterTypes[i];
if (type == null)
throw new ClassNotFoundException("parameter type must not be null", null);
if (parameterClasses == null)
parameterClasses = new Class<?>[i + 1];
if (type instanceof Class)
parameterClasses[i] = (Class<?>) type;
else if (type instanceof String)
parameterClasses[i] = findClass((String) type, classLoader);
else
throw new ClassNotFoundException("parameter type must either be specified as Class or String", null);
}
// if there are no arguments for the method
if (parameterClasses == null)
parameterClasses = new Class<?>[0];
return parameterClasses;
}
public static Class<?> findClass(String className, ClassLoader classLoader) throws ClassNotFoundException {
if (classLoader == null)
classLoader = ClassLoader.getSystemClassLoader();
return classLoader.loadClass(className);
}
public static ReflectObject wrap(Object object) {
return new ReflectObject(object);
}
public static class ReflectObject {
private Object object;
private ReflectObject(Object o) {
this.object = o;
}
public ReflectObject getChildField(String fieldName) throws Throwable {
Object child = ReflectUtils.findField(object.getClass(), fieldName).get(object);
return ReflectUtils.wrap(child);
}
public void setChildField(String fieldName, Object o) throws Throwable {
ReflectUtils.findField(object.getClass(), fieldName).set(object, o);
}
public ReflectObject callMethod(String methodName, Object... args) throws Throwable {
Class<?>[] clazzs = new Class[args.length];
for (int i = 0; i < args.length; i++) {
clazzs[i] = args.getClass();
}
Method method = ReflectUtils.findMethodExact(object.getClass(), methodName, clazzs);
return ReflectUtils.wrap(method.invoke(object, args));
}
public <T> T getAs(Class<T> clazz) {
return (T) object;
}
public <T> T get() {
return (T) object;
}
}
}
Following class I use to create a MediaPlayer object and. This works fine
import android.content.Context;
import android.media.MediaPlayer;
import android.view.View.OnClickListener;
public class PatientAlarm {
private static MediaPlayer md ;
private PatientAlarm() {
}
private PatientAlarm(Context context) {
md = MediaPlayer.create(context, R.raw.patient_alarm);
md.setLooping(true);
}
public static MediaPlayer getMediaPlayer(Context context) {
if (md == null) {
new PatientAlarm(context);
}
return md;
}
public static void startMediaPlayer(Context context) {
if (md == null) {
new PatientAlarm(context);
md.start();
} else {
if (!md.isPlaying()) {
new PatientAlarm(context);
md.start();
}
}
}
public static void stopMediaPlayer(OnClickListener onClickListener) {
if (md == null) {
} else {
if (md.isPlaying()) {
md.stop();
}
}
}
}
But the problem is Klocwork analyzer says
NPE.COND: Null pointer dereference of 'md' where null comes from condition : Java : PatientAlarm.java : Critical (1) : Analyze : Local
That occurs in below line
md.start();
I have no idea what it does mean. before start md, I check whether it is null.
Please guide me to make my code more reliable and how to solve this issue,
You totally messed up the concept of Object Oriented Programming.
You defined PatientAlarm class to incapsulate all logic of working with MediaPlayer. It's OK.
But why did you make all methods static? Why new PatientAlarm() called inside these methods and created instance even not assigned to some variable or field that makes it target for garbage collection?
This is example of how you should do it:
public class PatientAlarm {
private MediaPlayer md;
public PatientAlarm(Context context) {
md = MediaPlayer.create(context, R.raw.patient_alarm);
md.setLooping(true);
md.prepare();
}
public void start() {
if (!md.isPlaying()) {
md.start();
}
}
public void stop() {
if (md.isPlaying()) {
md.stop();
}
}
}
Adapt it to your case and read more about using MediaPlayer class.
which md.start(); line? there are 2... anyway your code is totally vulnerable for concurrency issues, you may read about locks to prevent it, but I would start form refactoring, before you get into advanced stuff. Creating a new object just to initialize a static member of the class is probably the most ugly approach for singleton I have ever seen.. If you really need to, use static method to do it for you, at least there wont be a new object for GC to collect. But in fact the use of static object in your example seems to be a miss first of all. Try rewriting it without static fields or methods and most likely your code will be simpler and more reliable.
I've been experimenting with using flow and mortar as an alternative architecture for our Android apps. I've been working on an app which at the minute is only a single phone layout, but I was wondering how the flow and mortar architecture might work if you want to have a different layout for tablets. Master details might be the simplest example, but there are obviously other examples.
I have a few ideas how this could work, but I wanted to know what the square developers might have thought about already around this topic.
We're still working on a canonical answer for this, but the basic idea is that you let the resource system change what views you're showing in which situation. So your activity sets its content view to, say, R.layout.root_view. The tablet version of that layout (we put it in res/layout-sw600dp) can be tied to different views, which might inject different presenters, and so on.
For cases where you need to make a runtime decision, define a boolean resource in values/bools .xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<bool name="show_tablet_ui">false</bool>
</resources>
and values-sw600dp/bools.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<bool name="show_tablet_ui">true</bool>
</resources>
Expose it to the rest of the app via dagger. Use this binding annotation:
/**
* Whether we should show a tablet UI.
*/
#Retention(RUNTIME) #Qualifier
public #interface ShowTabletUi {
int ID = R.bool.show_tablet_ui;
}
and a provider method like:
/**
* Singleton because there's no reason to read it from resources again,
* it won't change.
*/
#Provides #ShowTabletUi #Singleton boolean showTabletUi(Resources resources) {
return resources.getBoolean(ShowTabletUi.ID);
}
But wait there's more! Suppose you want to have a single screen / blueprint definition that manufactures different modules for different form factors. We've started using an annotation scheme to simplify that kind of thing. Instead of making our screen classes all implement BluePrint, we've started using some annotations to declare their interface class. In that world here's how a screen can selectively choose what modules to use for tablet or mobile.
#Layout(R.layout.some_view) #WithModuleFactory(SomeScreen.ModuleFactory.class)
public class SomeScreen {
public static class ModuleFactory extends ResponsiveModuleFactory<HomeScreen> {
#Override protected Object createTabletModule(HomeScreen screen) {
return new TabletModule();
}
#Override protected Object createMobileModule(HomeScreen screen) {
return new MobileModule();
}
}
Magic, right? Here's what's behind the curtain. First, a ModuleFactory is some static class that is given access to the screen and the resources and spits out a dagger module.
public abstract class ModuleFactory<T> {
final Blueprint createBlueprint(final Resources resources, final MortarScreen screen) {
return new Blueprint() {
#Override public String getMortarScopeName() {
return screen.getName();
}
#Override public Object getDaggerModule() {
return ModuleFactory.this.createDaggerModule(resources, (T) screen);
}
};
}
protected abstract Object createDaggerModule(Resources resources, T screen);
}
Our trixie ResponsiveModuleFactory subclass looks like this. (Remember how ShowTabletUi.java defined the resource id as a constant? This is why.)
public abstract class ResponsiveModuleFactory<T> extends ModuleFactory<T> {
#Override protected final Object createDaggerModule(Resources resources, T screen) {
boolean showTabletUi = resources.getBoolean(ShowTabletUi.ID);
return showTabletUi ? createTabletModule(screen) : createMobileModule(screen);
}
protected abstract Object createTabletModule(T screen);
protected abstract Object createMobileModule(T screen);
}
To make all this go, we have a ScreenScoper class (below). In the Mortar sample code, you'd make the ScreenConductor use one of these to create and destroy scopes. Sooner or later (soon I hope) Mortar and/or its samples will be updated to include this stuff.
package mortar;
import android.content.Context;
import android.content.res.Resources;
import com.squareup.util.Objects;
import dagger.Module;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.LinkedHashMap;
import java.util.Map;
import static java.lang.String.format;
/**
* Creates {#link MortarScope}s for screens that may be annotated with {#link WithModuleFactory},
* {#link WithModule} or {#link Module}.
*/
public class ScreenScoper {
private static final ModuleFactory NO_FACTORY = new ModuleFactory() {
#Override protected Object createDaggerModule(Resources resources, Object screen) {
throw new UnsupportedOperationException();
}
};
private final Map<Class, ModuleFactory> moduleFactoryCache = new LinkedHashMap<>();
public MortarScope getScreenScope(Context context, final MortarScreen screen) {
MortarScope parentScope = Mortar.getScope(context);
return getScreenScope(context.getResources(), parentScope, screen);
}
/**
* Finds or creates the scope for the given screen, honoring its optoinal {#link
* WithModuleFactory} or {#link WithModule} annotation. Note the scopes are also created
* for unannotated screens.
*/
public MortarScope getScreenScope(Resources resources, MortarScope parentScope,
final MortarScreen screen) {
ModuleFactory moduleFactory = getModuleFactory(screen);
MortarScope childScope;
if (moduleFactory != NO_FACTORY) {
Blueprint blueprint = moduleFactory.createBlueprint(resources, screen);
childScope = parentScope.requireChild(blueprint);
} else {
// We need every screen to have a scope, so that anything it injects is scoped. We need
// this even if the screen doesn't declare a module, because Dagger allows injection of
// objects that are annotated even if they don't appear in a module.
Blueprint blueprint = new Blueprint() {
#Override public String getMortarScopeName() {
return screen.getName();
}
#Override public Object getDaggerModule() {
return null;
}
};
childScope = parentScope.requireChild(blueprint);
}
return childScope;
}
private ModuleFactory getModuleFactory(MortarScreen screen) {
Class<?> screenType = Objects.getClass(screen);
ModuleFactory moduleFactory = moduleFactoryCache.get(screenType);
if (moduleFactory != null) return moduleFactory;
WithModule withModule = screenType.getAnnotation(WithModule.class);
if (withModule != null) {
Class<?> moduleClass = withModule.value();
Constructor<?>[] constructors = moduleClass.getDeclaredConstructors();
if (constructors.length != 1) {
throw new IllegalArgumentException(
format("Module %s for screen %s should have exactly one public constructor",
moduleClass.getName(), screen.getName()));
}
Constructor constructor = constructors[0];
Class[] parameters = constructor.getParameterTypes();
if (parameters.length > 1) {
throw new IllegalArgumentException(
format("Module %s for screen %s should have 0 or 1 parameter", moduleClass.getName(),
screen.getName()));
}
Class screenParameter;
if (parameters.length == 1) {
screenParameter = parameters[0];
if (!screenParameter.isInstance(screen)) {
throw new IllegalArgumentException(format("Module %s for screen %s should have a "
+ "constructor parameter that is a super class of %s", moduleClass.getName(),
screen.getName(), screen.getClass().getName()));
}
} else {
screenParameter = null;
}
try {
if (screenParameter == null) {
moduleFactory = new NoArgsFactory(constructor);
} else {
moduleFactory = new SingleArgFactory(constructor);
}
} catch (Exception e) {
throw new RuntimeException(
format("Failed to instantiate module %s for screen %s", moduleClass.getName(),
screen.getName()), e);
}
}
if (moduleFactory == null) {
WithModuleFactory withModuleFactory = screenType.getAnnotation(WithModuleFactory.class);
if (withModuleFactory != null) {
Class<? extends ModuleFactory> mfClass = withModuleFactory.value();
try {
moduleFactory = mfClass.newInstance();
} catch (Exception e) {
throw new RuntimeException(format("Failed to instantiate module factory %s for screen %s",
withModuleFactory.value().getName(), screen.getName()), e);
}
}
}
if (moduleFactory == null) moduleFactory = NO_FACTORY;
moduleFactoryCache.put(screenType, moduleFactory);
return moduleFactory;
}
private static class NoArgsFactory extends ModuleFactory<Object> {
final Constructor moduleConstructor;
private NoArgsFactory(Constructor moduleConstructor) {
this.moduleConstructor = moduleConstructor;
}
#Override protected Object createDaggerModule(Resources resources, Object ignored) {
try {
return moduleConstructor.newInstance();
} catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
throw new RuntimeException(e);
}
}
}
private static class SingleArgFactory extends ModuleFactory {
final Constructor moduleConstructor;
public SingleArgFactory(Constructor moduleConstructor) {
this.moduleConstructor = moduleConstructor;
}
#Override protected Object createDaggerModule(Resources resources, Object screen) {
try {
return moduleConstructor.newInstance(screen);
} catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
throw new RuntimeException(e);
}
}
}
}
I am trying to use a singleton class to create this database because I need it to be open for each of the activities in the application. I keep getting a null pointer error from either the "getFilesDir" or "if(instance == null) calls, and since I am not that familiar with android programming I am not sure what is going on.
package com.database;
import java.io.File;
import android.app.Application;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.util.Log;
import com.businessclasses.Field;
import com.db4o.Db4oEmbedded;
import com.db4o.ObjectContainer;
import com.db4o.config.AndroidSupport;
import com.db4o.config.EmbeddedConfiguration;
public final class anotherTest extends Application {
private static ObjectContainer playsDB;
private static ObjectContainer gamePlanDB;
private anotherTest instance;
public anotherTest(){
final EmbeddedConfiguration config = Db4oEmbedded.newConfiguration();
config.common().add(new AndroidSupport());
//instance.getFilesDir().getPath()
new File(getFilesDir().getPath(), "/PlaysDB.db4o").delete();
Log.d("db", "" + instance.getFilesDir().getPath());
//getFilesDir().getPath();
//String appPath = "/data/data/PlaysDB/database";
playsDB = Db4oEmbedded.openFile(config, getFilesDir().getPath() + "/PlaysDB.db4o");
//File test = new File(appPath + "/PlaysDB.db4o");
//if(test != null){
// Log.d("db", "file was created");
// Log.d("db", "path >> " + test.getAbsolutePath());
//test.delete();
//}
//playsDB = Db4oEmbedded.openFile(config, appPath + "/PlaysDB.db4o");
}
public synchronized anotherTest getInstance(){
if(instance == null){
instance = new anotherTest();
}
return instance;
}
public void storePlay(Field field){
if(field != null){
if(playsDB == null){
Log.d("db", "database is null");
}
playsDB.store(field);
playsDB.commit();
Log.d("added play", "play added to db");
}
else{
Log.e("field input null", "play not added to db");
}
}
}
And here is my call in one of the activities.
public void onClick(View v) {
String formation = playFormation.getText().toString();
String name = playName.getText().toString();
String type = playType.getSelectedItem().toString();
//TODO:send to database
Field newField = new Field();
newField.setPlayName(name);
newField.setPlayType(type);
anotherTest temp = new anotherTest();
temp.getInstance().storePlay(newField);
}
Have been trying to make this database work for the past few weeks to no avail. Any help or guidance would be greatly appreciated.
The way this is structured doesn't make sense.
Java classes are always named with proper case - so it should be "AnotherTest".
You're not actually creating a singleton, because neither your instance, nor your getInstance() are static. Also, you never access your instance via "getInstance()".
You have a class AnotherTest, which has as a field an instance of AnotherTest, which is never, ever initialised, and which is accessed in the constructor of AnotherTest. This is just guaranteed to be null.
You are relying on implicit state of the Application superclass, which is never, ever provided because Application is supposed to be declared in the androidmanifest.xml, where it will be constructed for you. Meanwhile, you are constructing an instance manually in your event handler, so it has none of the state you expect - but anyway, it will fall over in its own constructor because it tries to reference a null pointer to itself, as mentioned above.
Your problems are nothing to do with DB40, and everything to do with not understanding what you're doing.
It needs to be way more like:
public final class AnotherTest {
private static AnotherTest instance;
private final Context context;
private AnotherTest(Context context){
this.context = context;
// Do whatever you need to do with DB4O using *only* the supplied context here
}
public static synchronized AnotherTest getInstance(Context context){
if(instance == null){
instance = new AnotherTest(context);
}
return instance;
}
}
And in the event handler:
AnotherTest.getInstance(Context.getApplicationContext()).storePlay(newField);
I found an issue when I am doing CTS R12 test for Android 2.3.x.
During the media stress test, the cases all failed because of file exception.
It is caused by the static variable "FILE_PATH" is null during the test case.
I found it is 100% reproducible on NexusOne/NexusS with Android 2.3.6.
I also write an very simple test project to test it, code attached below.
The activity code:
package com.hw.hello;
import android.app.Activity;
import android.os.Bundle;
public class HelloActivity extends Activity {
/** Called when the activity is first created. */
#Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
The test case code:
package com.hw.hello.test;
import com.hw.hello.HelloActivity;
import android.test.ActivityInstrumentationTestCase2;
import android.util.Log;
public class HelloTest extends ActivityInstrumentationTestCase2<HelloActivity> {
private static final String STR;
static {
STR = "XXXXXX";
}
public HelloTest() {
super("com.hw.hello", HelloActivity.class);
}
#Override
public void setUp() {
}
public void test1() {
Log.d("111111", "STR="+STR);
}
public void test2() {
Log.d("222222", "STR="+STR);
}
}
When you run it, you will find the result is:
02-24 01:24:04.280: D/111111(28075): STR=XXXXXX
02-24 01:24:04.327: D/222222(28075): STR=null
I know Google has fixed this on ICS.
But I found that the change of Dalvik VM is to much to merge to 2.3.7.
What can I do to fix this on 2.3.7 to get through by CTS R12?
================================================================================
I cannot answer my question myself within 8 hours.
So I have the answer here:
My French Colleague gave me the hint to find the final resolution:
I have found some change in ICS source code of ActivityTestCase.java
The change is an added condition:
&& (field.getModifiers() & Modifier.FINAL) == 0
#Override
protected void scrubClass(final Class<?> testCaseClass)
throws IllegalAccessException {
final Field[] fields = getClass().getDeclaredFields();
for (Field field : fields) {
final Class<?> fieldClass = field.getDeclaringClass();
if (testCaseClass.isAssignableFrom(fieldClass) && !field.getType().isPrimitive()
&& (field.getModifiers() & Modifier.FINAL) == 0) {
try {
field.setAccessible(true);
field.set(this, null);
} catch (Exception e) {
android.util.Log.d("TestCase", "Error: Could not nullify field!");
}
if (field.get(this) != null) {
android.util.Log.d("TestCase", "Error: Could not nullify field!");
}
}
}
}
I put this section of code into my test case class to override the super class' method, the issue is fixed now.
As #Malcolm 's request
I cannot answer my question myself within 8 hours. So I have the answer here:
My French Colleague gave me the hint to find the final resolution: I have found some change in ICS source code of ActivityTestCase.java
The change is an added condition: && (field.getModifiers() & Modifier.FINAL) == 0
#Override
protected void scrubClass(final Class<?> testCaseClass)
throws IllegalAccessException {
final Field[] fields = getClass().getDeclaredFields();
for (Field field : fields) {
final Class<?> fieldClass = field.getDeclaringClass();
if (testCaseClass.isAssignableFrom(fieldClass) && !field.getType().isPrimitive()
&& (field.getModifiers() & Modifier.FINAL) == 0) {
try {
field.setAccessible(true);
field.set(this, null);
} catch (Exception e) {
android.util.Log.d("TestCase", "Error: Could not nullify field!");
}
if (field.get(this) != null) {
android.util.Log.d("TestCase", "Error: Could not nullify field!");
}
}
}
}
Well, you can make sure your static fields gets the appropriate value inside the constructor. Yep, it's an ugly hack but it works.