如何保存意图对象并稍后检索它

Question

我想保存一个 Intent 对象，它有自己的一组与之关联的属性，然后再检索它，这样我只需要编写

startActivity(intentObject);

这样做的最佳做法是什么？ 我已经阅读了有关 Google Gson 和对象序列化/parcelable 实现的信息，但无法掌握它。

示例场景：

活动 1

Intent abc = new Intent ();
abc.setClass(); //set class here
abc.setExtra(); //set some extras

其他活动

//code to retrieve abc Intent object

PS。 - 我知道活动之间通过意图进行通信，但这不是两个活动之间通信的情况。

编辑 1

请记住，意图是由另一个用户设置的，所以我不完全知道与之关联的属性是什么。也将其转换为 Json 字符串或序列化/使其可 Parcelable 不是我正在寻找的东西。有什么想法吗？

编辑 2

到目前为止，我尝试的是使用 Jackson library 将该 Intentobject 转换为 Json，然后通过解析该 json 来设置新的意图。我害怕的是丢失一些可能无法转换为 Json 的重要属性。

谢谢，
山塔努

Answer 1

正如您的评论所说，是的，您可以使 Intent 对象全局可访问，但这并不是正确的方法。你不知道什么时候可以再次调用。虽然它只是在那里“等待”，但它正在使用内存，如果应用程序关闭，它是一个临时解决方案。

我不会称这是“最好”的方式，但它确实有效：

myButton.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
        SharedPreferences.Editor editor = preferences.edit();

        editor.putString("class_name", SomeOtherActivity.class.getSimpleName());
        // add your other properties here
        editor.apply();
        // then continue with your work, maybe start the new activity
    }
}); 

然后从其他地方，你可以这样做：

SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(getApplicationContext();
String className = preferences.getString("class_name", "");
// get your other properties here

if(!className.isEmpty()) {
    try {
        Intent intent = new Intent(this, Class.forName(className));
        // add the retreived properties here
        startActivity(intent);
    } catch (Exception e) {
        Log.e(TAG, e.toString());
    }
}

Answer 2

在研究了很多天之后，我了解到虽然有很多方法可以将 Intent 转换为字节流，但没有合适的方法来存储和检索具有与之关联的外星人（对我们而言）属性的 Intent 对象。 以下是我自己的逻辑。我首先使用 Jackson 将意图对象转换为 json 字符串，然后解析该 json 并将属性设置为新的意图对象。

对于 json 的意图：

public String intentToJSON(Context con,Intent intent) throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();

    String getClassName = null;
    getClassName = intent.getComponent().getClassName();
    String getContextName = null;
    getContextName = con.getClass().getName() + ".this";
    HashMap<String, String> makeInsideJsonArray = new HashMap<String, String>();

    HashMap<String, String> hashMap = new HashMap<String, String>();
    hashMap.put("className",getClassName);
    hashMap.put("context",getContextName);
    Bundle bundle = intent.getExtras();
    if (bundle != null) {
        Set<String> keys = bundle.keySet();
        Iterator<String> it = keys.iterator();
        Log.d("SappsnoopDog",""+keys.size());
        while (it.hasNext()) {
            String key = it.next();

            Log.d("Sapptagdog","TYPE   " + bundle.get(key).toString());
            Log.d("NERVE",""+bundle.get(key).getClass().getAnnotations());


            String type = bundle.get(key).getClass().getSimpleName();
            Log.d("SappDogTAG",key + " OF TYPE " + type);
            switch (type) {
                case "String":
                    makeInsideJsonArray.put(key,type+ LibraryDatabase.JSONSEPERATOR +bundle.get(key).toString());
                    Log.d("SappDogTAG","bool array");
                    break;
                case "String[]":
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+bundle.get(key).toString().replace(" ",""));
                    Log.d("SappDogTAG","bool array");
                    break;
                case "Integer":
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+bundle.get(key).toString());

                    Log.d("SappDogTAG","bool array");
                    break;
                case "Double":
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+bundle.get(key).toString());
                    Log.d("SappDogTAG","bool array");
                    break;
                case  "double[]":

                    double[] newDouble = (double[]) bundle.get(key);
                    String fromDouble = Arrays.toString(newDouble);
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+fromDouble.replace(" ",""));
                    Log.d("SappDogTAG","bool array");
                    break;
                case "int[]":
                    int[] newArray = (int[]) bundle.get(key);
                    String fromArray = Arrays.toString(newArray);
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+fromArray.replace(" ",""));
                    Log.d("SappDogTAG","bool array");
                    break;
                case "Boolean":
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+bundle.get(key).toString());
                    Log.d("SappDogTAG","bool array");
                    break;
                case "boolean[]":

                    boolean[] newBool = (boolean[]) bundle.get(key);
                    String fromBool = Arrays.toString(newBool);
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+fromBool.replace(" ",""));
                    Log.d("SappDogTAG","bool array");
                    break;
                case "Char":
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+bundle.get(key).toString());
                    Log.d("SappDogTAG","bool array");
                    break;
                case "char[]":

                    char[] newChar = (char[]) bundle.get(key);
                    String fromChar = Arrays.toString(newChar);
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+fromChar.replace(" ",""));
                    Log.d("SappDogTAG","bool array");
                    break;
                case "CharSequence":
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+bundle.get(key).toString());
                    Log.d("SappDogTAG","bool array");
                    break;
                case "charsequence[]":

                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+bundle.get(key).toString().replace(" ",""));
                    Log.d("SappDogTAG","bool array");
                    break;
                case "Byte":
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+bundle.get(key).toString());
                    Log.d("SappDogTAG","bool array");
                    break;
                case "byte[]":

                    byte[] newByte = (byte[]) bundle.get(key);
                    String fromByte = Arrays.toString(newByte);
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+fromByte.replace(" ",""));
                    Log.d("SappDogTAG","bool array");
                    break;
                case "Float":
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+bundle.get(key).toString());
                    Log.d("SappDogTAG","bool array");
                    break;
                case "float[]":

                    float[] newFloat = (float[]) bundle.get(key);
                    String fromFloat = Arrays.toString(newFloat);
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+fromFloat.replace(" ",""));
                    Log.d("SappDogTAG","bool array");
                    break;
                case "Short":
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+bundle.get(key).toString());
                    Log.d("SappDogTAG","bool array");
                    break;
                case "short[]":

                    short[] newShort = (short[]) bundle.get(key);
                    String fromShort = Arrays.toString(newShort);
                    fromShort = fromShort.replace(" ","");
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+fromShort.replace(" ",""));
                    Log.d("SappDogTAG","bool array");
                    break;
                case "Long":
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+bundle.get(key).toString());
                    Log.d("SappDogTAG","bool array");
                    break;
                case "long[]":

                    long[] newLong = (long[]) bundle.get(key);
                    String fromLong = Arrays.toString(newLong);
                    makeInsideJsonArray.put(key,type+LibraryDatabase.JSONSEPERATOR+bundle.get(key).toString().replace(" ",""));
                    Log.d("SappDogTAG","bool array");
                    break;

                case "ArrayList":
                    ArrayList<Object> obj = (ArrayList<Object>) bundle.get(key);
                    Object[] objArr = obj.toArray();
                    if(objArr[0] instanceof Integer){
                        ArrayList<Integer> newIntegerArray = bundle.getIntegerArrayList(key);
                        makeInsideJsonArray.put(key,type+"Integer"+LibraryDatabase.JSONSEPERATOR+newIntegerArray.toString().replace(" ",""));

                    }else if(objArr[0] instanceof String){
                        ArrayList<String> newStringArray = bundle.getStringArrayList(key);

                        makeInsideJsonArray.put(key,type+"String"+LibraryDatabase.JSONSEPERATOR+newStringArray.toString().replace(" ",""));

                    }
                    break;

                default:
                    // whatever
            }

            hashMap.put(key, bundle.get(key).toString());
        }
    }
    String passArray = mapper.writeValueAsString(makeInsideJsonArray);
    hashMap.put("intentExtras",passArray);
    Log.d("GOGTAD",""+passArray);

    String intentString  = mapper.writeValueAsString(intent);
    Log.d("IntentString", "" + mapper.writeValueAsString(hashMap));
    StringBuilder a1S = new StringBuilder(mapper.writeValueAsString(hashMap));
    a1S.deleteCharAt(mapper.writeValueAsString(hashMap).length()-1);
    a1S.append(",");
    String s1t = a1S.toString();

    StringBuilder sb = new StringBuilder(intentString);
    sb.deleteCharAt(0);
    String retrString = sb.toString();
    StringBuilder newS = new StringBuilder();
    newS.append(s1t);
    newS.append(retrString);
    Log.d("Insnsns",newS.toString());
    return newS.toString();
}

对于 json 的意图：

 public Intent jsonToINTENT(String JSONString) throws JSONException {

    JSONObject jsonObject = new JSONObject(JSONString.toString());
    String toArray = jsonObject.get("intentExtras").toString();
    String contextName = "com.hanuor.sapphiredemo";
    String className = jsonObject.get("className").toString();
    Log.d("Insass",className.toString());

    Intent setIntent = new Intent();
    setIntent.setClassName(contextName, className);
    HashMap<String, String> extrasHash = new HashMap<String, String>();
    JSONObject issueObj = new JSONObject(toArray);
    for (int i = 0; i < issueObj.length(); i++) {
        extrasHash.put(issueObj.names().getString(i), issueObj.get(issueObj.names().getString(i)).toString());
    }
    Iterator it = extrasHash.entrySet().iterator();
    while (it.hasNext()) {
        //add conditions  and checks here

        Map.Entry pair = (Map.Entry) it.next();
        String currentKey = (String) pair.getKey();
        Log.d("HAHA",""+currentKey);
        String[] getValuethroughSplit = pair.getValue().toString().split(LibraryDatabase.JSONSEPERATOR);
        String dataType = getValuethroughSplit[0];
        String  value = (String) getValuethroughSplit[2];
        Log.d("Insamareen",getValuethroughSplit.length + " " +dataType+ " " +value.toString());
        switch (dataType) {
            case "String":
                setIntent.putExtra(currentKey,(String) value);
                break;
            case "String[]":
                String comp1 = value.substring(1,value.length()-1);
                String[] comp2 = comp1.split(",");
                setIntent.putExtra(currentKey,comp2);
                break;
            case "Integer":
                setIntent.putExtra(currentKey,Integer.parseInt(value));
                break;
            case "Double":

                setIntent.putExtra(currentKey,Double.parseDouble(value));

                break;
            case  "double[]":
                String compDouble1 = value.substring(1,value.length()-1);
                String[] compDoub2 = compDouble1.split(",");
                double[] db = new double[compDoub2.length];
                for(int i = 0; i<compDoub2.length; i++){
                    db[i] = Double.parseDouble(compDoub2[i]);
                }
                setIntent.putExtra(currentKey,db);
                break;
            case "int[]":
                String compInt1 = value.substring(1,value.length()-1);
                String[] compInt2 = compInt1.split(",");
                int[] intVal = new int[compInt2.length];
                for(int i = 0; i<compInt2.length; i++){
                    intVal[i] = Integer.parseInt(compInt2[i]);
                }
                Log.d("Hankey",intVal.toString());
                setIntent.putExtra(currentKey,intVal);

                break;
            case "Boolean":
                setIntent.putExtra(currentKey,Boolean.valueOf(value));

                break;
            case "boolean[]":
                String compB1 = value.substring(1,value.length()-1);
                String[] compB2 = compB1.split(",");
                boolean[] BVal = new boolean[compB2.length];
                for(int i = 0; i<compB2.length; i++){
                    BVal[i] =Boolean.parseBoolean(compB2[i]);
                }
                setIntent.putExtra(currentKey, value);

                break;
            case "Char":
                setIntent.putExtra(currentKey,value);

                break;
            case "char[]":

                String ch1 = value.substring(1,value.length()-1);
                String[] ch2 = ch1.split(",");
                String newS = null;
                for(int i = 0; i<ch2.length; i++){
                    newS = newS + ch2[i];
                }
                setIntent.putExtra(currentKey,newS.toCharArray());

                break;
            case "CharSequence":
                setIntent.putExtra(currentKey,(CharSequence) value);

                break;
            case "Charsequence[]":
                setIntent.putExtra(currentKey,value.toString());

                break;
            case "Byte":
                setIntent.putExtra(currentKey,Byte.valueOf(value));

                break;
            case "byte[]":
                String by = value.substring(1,value.length()-1);
                String[] by2 = by.split(",");
                byte[] by3 = new byte[by2.length];
                for(int i = 0; i<by2.length; i++){
                    by3[i] =Byte.parseByte(by2[i]);
                }
                setIntent.putExtra(currentKey,by3);

                break;
            case "Float":
                setIntent.putExtra(currentKey,Float.valueOf(value));

                break;
            case "float[]":
                String fl = value.substring(1,value.length()-1);
                String[] fl2 = fl.split(",");
                float[] fl3 = new float[fl2.length];
                for(int i = 0; i<fl2.length; i++){
                    fl3[i] =Float.parseFloat(fl2[i]);
                }
                setIntent.putExtra(currentKey,fl3);

                break;
            case "Short":
                setIntent.putExtra(currentKey,Short.valueOf(value));

                break;
            case "short[]":
                String sh = value.substring(1,value.length()-1);
                String[] sh2 = sh.split(",");
                short[] sh3 = new short[sh2.length];
                for(int i = 0; i<sh2.length; i++){
                    sh3[i] =Short.parseShort(sh2[i]);
                }
                setIntent.putExtra(currentKey,sh3);

                break;
            case "Long":
                setIntent.putExtra(currentKey,Long.valueOf(value));

                break;
            case "long[]":
                String ll = value.substring(1,value.length()-1);
                String[] ll2 = ll.split(",");
                long[] ll3 = new long[ll2.length];
                for(int i = 0; i<ll2.length; i++){
                    ll3[i] =Long.parseLong(ll2[i]);
                }
                setIntent.putExtra(currentKey,ll3);

                break;

            case "ArrayListString":
                Log.d("Hankey",currentKey+" ");
                String arrL = value.substring(1,value.length()-1);
                String[] arrl2 = arrL.split(",");
                ArrayList<String> arrStr = new ArrayList<String>();
                for (int i = 0; i < arrl2.length; i++) {
                    arrStr.add(arrl2[i]);
                }
                setIntent.putStringArrayListExtra(currentKey, arrStr);

                break;
            case "ArrayListInteger":
                String arL = value.substring(1,value.length()-1);
                String[] arl2 = arL.split(",");
                ArrayList<Integer> arrInt = new ArrayList<Integer>();
                for(int i = 0; i<arl2.length; i++){
                    arrInt.add(Integer.parseInt(arl2[i]));
                }

                setIntent.putIntegerArrayListExtra(currentKey,arrInt);

                break;
            default:
                // whatever
        }
    }
    return setIntent;
}

在解析 Json 时，还有很多事情需要实现。我这样做只是为了设置关联的值。