src/com/android/telecomm/PhoneAccountRegistrar.java - android_packages_services_Telecomm - Gitiles

 /*
  * Copyright (C) 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.telecomm;

 import android.telecomm.PhoneAccount;
 import android.telecomm.PhoneAccountHandle;
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 import org.json.JSONTokener;

 import android.content.ComponentName;
 import android.content.Context;

 import android.content.SharedPreferences;
 import android.net.Uri;
 import android.telecomm.TelecommManager;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;

 /**
  * Handles writing and reading PhoneAccountHandle registration entries. This is a simple verbatim
  * delegate for all the account handling methods on {@link TelecommManager} as implemented in
  * {@link TelecommServiceImpl}, with the notable exception that {@link TelecommServiceImpl} is
  * responsible for security checking to make sure that the caller has proper authority over
  * the {@code ComponentName}s they are declaring in their {@code PhoneAccountHandle}s.
  *
  * TODO(santoscordon): Replace this implementation with a proper database stored in a Telecomm
  * provider.
  */
 final class PhoneAccountRegistrar {
     private static final String TELECOMM_PREFERENCES = "telecomm_prefs";
     private static final String PREFERENCE_PHONE_ACCOUNTS = "phone_accounts";

     private final Context mContext;
     private final State mState;

     PhoneAccountRegistrar(Context context) {
         mContext = context;
         mState = readState();
     }

     public PhoneAccountHandle getDefaultOutgoingPhoneAccount() {
         if (mState.defaultOutgoing != null) {
             // Return the registered outgoing default iff it still exists (we keep a sticky
             // default to survive account deletion and re-addition)
             for (int i = 0; i < mState.accounts.size(); i++) {
                 if (mState.accounts.get(i).getAccountHandle().equals(mState.defaultOutgoing)) {
                     return mState.defaultOutgoing;
                 }
             }
             // At this point, there was a registered default but it has been deleted; proceed
             // as though there were no default
         }

         List<PhoneAccountHandle> enabled = getEnabledPhoneAccounts();
         switch (enabled.size()) {
             case 0:
                 // There are no accounts, so there can be no default
                 return null;
             case 1:
                 // There is only one account, which is by definition the default
                 return enabled.get(0);
             default:
                 // There are multiple accounts with no selected default
                 return null;
         }
     }

     public void setDefaultOutgoingPhoneAccount(PhoneAccountHandle accountHandle) {
         if (accountHandle == null) {
             // Asking to clear the default outgoing is a valid request
             mState.defaultOutgoing = null;
         } else {
             boolean found = false;
             for (PhoneAccount m : mState.accounts) {
                 if (Objects.equals(accountHandle, m.getAccountHandle())) {
                     found = true;
                     break;
                 }
             }

             if (!found) {
                 Log.w(this, "Trying to set nonexistent default outgoing phone accountHandle %s",
                         accountHandle);
                 return;
             }

             mState.defaultOutgoing = accountHandle;
         }

         write();
     }

     public void setSimCallManager(PhoneAccountHandle callManager) {
         if (callManager != null) {
             PhoneAccount callManagerAccount = getPhoneAccount(callManager);
             if (callManagerAccount == null) {
                 Log.d(this, "setSimCallManager: Nonexistent call manager: %s", callManager);
                 return;
             } else if (!has(callManagerAccount, PhoneAccount.CAPABILITY_SIM_CALL_MANAGER)) {
                 Log.d(this, "setSimCallManager: Not a call manager: %s", callManagerAccount);
                 return;
             }
         }
         mState.simCallManager = callManager;
         write();
     }

     public PhoneAccountHandle getSimCallManager() {
         return mState.simCallManager;
     }

     public List<PhoneAccountHandle> getAllPhoneAccountHandles() {
         List<PhoneAccountHandle> accountHandles = new ArrayList<>();
         for (PhoneAccount m : mState.accounts) {
             accountHandles.add(m.getAccountHandle());
         }
         return accountHandles;
     }

     public List<PhoneAccount> getAllPhoneAccounts() {
         return new ArrayList<>(mState.accounts);
     }

     // TODO: Rename systemwide to "getCallProviderPhoneAccounts"?
     public List<PhoneAccountHandle> getEnabledPhoneAccounts() {
         return getCallProviderAccountHandles();
     }

     public PhoneAccount getPhoneAccount(PhoneAccountHandle handle) {
         for (PhoneAccount m : mState.accounts) {
             if (Objects.equals(handle, m.getAccountHandle())) {
                 return m;
             }
         }
         return null;
     }

     // TODO: Should we implement an artificial limit for # of accounts associated with a single
     // ComponentName?
     public void registerPhoneAccount(PhoneAccount account) {
         account = hackFixBabelAccount(account);
         mState.accounts.add(account);
         // Search for duplicates and remove any that are found.
         for (int i = 0; i < mState.accounts.size() - 1; i++) {
             if (Objects.equals(
                     account.getAccountHandle(), mState.accounts.get(i).getAccountHandle())) {
                 // replace existing entry.
                 mState.accounts.remove(i);
                 break;
             }
         }

         write();
     }

     // STOPSHIP: Hack to edit the account registered by Babel so it shows up properly
     private PhoneAccount hackFixBabelAccount(PhoneAccount account) {
         String pkg = account.getAccountHandle().getComponentName().getPackageName();
         return "com.google.android.talk".equals(pkg)
                 ? new PhoneAccount(
                         account.getAccountHandle(),
                         account.getHandle(),
                         account.getSubscriptionNumber(),
                         PhoneAccount.CAPABILITY_SIM_CALL_MANAGER,
                         account.getIconResId(),
                         account.getLabel(),
                         account.getShortDescription(),
                         account.isVideoCallingSupported())
                 : account;
     }

     public void unregisterPhoneAccount(PhoneAccountHandle accountHandle) {
         for (int i = 0; i < mState.accounts.size(); i++) {
             if (Objects.equals(accountHandle, mState.accounts.get(i).getAccountHandle())) {
                 mState.accounts.remove(i);
                 break;
             }
         }

         write();
     }

     public void clearAccounts(String packageName) {
         for (int i = 0; i < mState.accounts.size(); i++) {
             if (Objects.equals(
                     packageName,
                     mState.accounts.get(i).getAccountHandle()
                             .getComponentName().getPackageName())) {
                 mState.accounts.remove(i);
             }
         }

         write();
     }

     ////////////////////////////////////////////////////////////////////////////////////////////////

     // TODO: Add a corresponding has(...) method to class PhoneAccount itself and remove this one
     // Return true iff the given account has all the specified capability flags
     static boolean has(PhoneAccount account, int capability) {
         return (account.getCapabilities() & capability) == capability;
     }

     private List<PhoneAccountHandle> getCallProviderAccountHandles() {
         List<PhoneAccountHandle> accountHandles = new ArrayList<>();
         for (PhoneAccount m : mState.accounts) {
             if (has(m, PhoneAccount.CAPABILITY_CALL_PROVIDER)) {
                 accountHandles.add(m.getAccountHandle());
             }
         }
         return accountHandles;
     }

     /**
      * The state of this {@code PhoneAccountRegistrar}.
      */
     private static class State {
         /**
          * The account selected by the user to be employed by default for making outgoing calls.
          * If the user has not made such a selection, then this is null.
          */
         public PhoneAccountHandle defaultOutgoing = null;

         /**
          * A {@code PhoneAccount} having {@link PhoneAccount#CAPABILITY_SIM_CALL_MANAGER} which
          * manages and optimizes a user's PSTN SIM connections.
          */
         public PhoneAccountHandle simCallManager;

         /**
          * The complete list of {@code PhoneAccount}s known to the Telecomm subsystem.
          */
         public final List<PhoneAccount> accounts = new ArrayList<>();
     }

     ////////////////////////////////////////////////////////////////////////////////////////////////
     //
     // State management
     //

     private void write() {
         writeState(mState);
     }

     private State readState() {
         try {
             String serialized = getPreferences().getString(PREFERENCE_PHONE_ACCOUNTS, null);
             Log.v(this, "read() obtained serialized state: %s", serialized);
             State state = serialized == null
                     ? new State()
                     : deserializeState(serialized);
             Log.v(this, "read() obtained state: %s", state);
             return state;
         } catch (JSONException e) {
             Log.e(this, e, "read");
             return new State();
         }
     }

     private boolean writeState(State state) {
         try {
             Log.v(this, "write() writing state: %s", state);
             String serialized = serializeState(state);
             Log.v(this, "write() writing serialized state: %s", serialized);
             boolean success = getPreferences()
                     .edit()
                     .putString(PREFERENCE_PHONE_ACCOUNTS, serialized)
                     .commit();
             Log.v(this, "serialized state was written with success = %b", success);
             return success;
         } catch (JSONException e) {
             Log.e(this, e, "write");
             return false;
         }
     }

     private SharedPreferences getPreferences() {
         return mContext.getSharedPreferences(TELECOMM_PREFERENCES, Context.MODE_PRIVATE);
     }

     private String serializeState(State s) throws JSONException {
         // TODO: If this is used in production, remove the indent (=> do not pretty print)
         return sStateJson.toJson(s).toString(2);
     }

     private State deserializeState(String s) throws JSONException {
         return sStateJson.fromJson(new JSONObject(new JSONTokener(s)));
     }

     ////////////////////////////////////////////////////////////////////////////////////////////////
     //
     // JSON serialization
     //

     private interface Json<T> {
         JSONObject toJson(T o) throws JSONException;
         T fromJson(JSONObject json) throws JSONException;
     }

     private static final Json<State> sStateJson =
             new Json<State>() {
         private static final String DEFAULT_OUTGOING = "default_outgoing";
         private static final String SIM_CALL_MANAGER = "sim_call_manager";
         private static final String ACCOUNTS = "accounts";

         @Override
         public JSONObject toJson(State o) throws JSONException {
             JSONObject json = new JSONObject();
             if (o.defaultOutgoing != null) {
                 json.put(DEFAULT_OUTGOING, sPhoneAccountHandleJson.toJson(o.defaultOutgoing));
             }
             if (o.simCallManager != null) {
                 json.put(SIM_CALL_MANAGER, sPhoneAccountHandleJson.toJson(o.simCallManager));
             }
             JSONArray accounts = new JSONArray();
             for (PhoneAccount m : o.accounts) {
                 accounts.put(sPhoneAccountJson.toJson(m));
             }
             json.put(ACCOUNTS, accounts);
             return json;
         }

         @Override
         public State fromJson(JSONObject json) throws JSONException {
             State s = new State();
             if (json.has(DEFAULT_OUTGOING)) {
                 try {
                     s.defaultOutgoing = sPhoneAccountHandleJson.fromJson(
                             (JSONObject) json.get(DEFAULT_OUTGOING));
                 } catch (Exception e) {
                     Log.e(this, e, "Extracting PhoneAccountHandle");
                 }
             }
             if (json.has(SIM_CALL_MANAGER)) {
                 try {
                     s.simCallManager = sPhoneAccountHandleJson.fromJson(
                             (JSONObject) json.get(SIM_CALL_MANAGER));
                 } catch (Exception e) {
                     Log.e(this, e, "Extracting PhoneAccountHandle");
                 }
             }
             if (json.has(ACCOUNTS)) {
                 JSONArray accounts = (JSONArray) json.get(ACCOUNTS);
                 for (int i = 0; i < accounts.length(); i++) {
                     try {
                         s.accounts.add(sPhoneAccountJson.fromJson(
                                 (JSONObject) accounts.get(i)));
                     } catch (Exception e) {
                         Log.e(this, e, "Extracting phone account");
                     }
                 }
             }
             return s;
         }
     };

     private static final Json<PhoneAccount> sPhoneAccountJson =
             new Json<PhoneAccount>() {
         private static final String ACCOUNT = "account";
         private static final String HANDLE = "handle";
         private static final String SUBSCRIPTION_NUMBER = "subscription_number";
         private static final String CAPABILITIES = "capabilities";
         private static final String ICON_RES_ID = "icon_res_id";
         private static final String LABEL = "label";
         private static final String SHORT_DESCRIPTION = "short_description";
         private static final String VIDEO_CALLING_SUPPORTED = "video_calling_supported";

         @Override
         public JSONObject toJson(PhoneAccount o) throws JSONException {
             return new JSONObject()
                     .put(ACCOUNT, sPhoneAccountHandleJson.toJson(o.getAccountHandle()))
                     .put(HANDLE, o.getHandle().toString())
                     .put(SUBSCRIPTION_NUMBER, o.getSubscriptionNumber())
                     .put(CAPABILITIES, o.getCapabilities())
                     .put(ICON_RES_ID, o.getIconResId())
                     .put(LABEL, o.getLabel())
                     .put(SHORT_DESCRIPTION, o.getShortDescription())
                     .put(VIDEO_CALLING_SUPPORTED, (Boolean) o.isVideoCallingSupported());
         }

         @Override
         public PhoneAccount fromJson(JSONObject json) throws JSONException {
             return new PhoneAccount(
                     sPhoneAccountHandleJson.fromJson((JSONObject) json.get(ACCOUNT)),
                     Uri.parse((String) json.get(HANDLE)),
                     (String) json.get(SUBSCRIPTION_NUMBER),
                     (int) json.get(CAPABILITIES),
                     (int) json.get(ICON_RES_ID),
                     (String) json.get(LABEL),
                     (String) json.get(SHORT_DESCRIPTION),
                     (Boolean) json.get(VIDEO_CALLING_SUPPORTED));
         }
     };

     private static final Json<PhoneAccountHandle> sPhoneAccountHandleJson =
             new Json<PhoneAccountHandle>() {
         private static final String COMPONENT_NAME = "component_name";
         private static final String ID = "id";

         @Override
         public JSONObject toJson(PhoneAccountHandle o) throws JSONException {
             return new JSONObject()
                     .put(COMPONENT_NAME, o.getComponentName().flattenToString())
                     .put(ID, o.getId());
         }

         @Override
         public PhoneAccountHandle fromJson(JSONObject json) throws JSONException {
             return new PhoneAccountHandle(
                     ComponentName.unflattenFromString((String) json.get(COMPONENT_NAME)),
                     (String) json.get(ID));
         }
     };
 }
	/*
	* Copyright (C) 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.telecomm;

	import android.telecomm.PhoneAccount;
	import android.telecomm.PhoneAccountHandle;
	import org.json.JSONArray;
	import org.json.JSONException;
	import org.json.JSONObject;
	import org.json.JSONTokener;

	import android.content.ComponentName;
	import android.content.Context;

	import android.content.SharedPreferences;
	import android.net.Uri;
	import android.telecomm.TelecommManager;

	import java.util.ArrayList;
	import java.util.List;
	import java.util.Objects;

	/**
	* Handles writing and reading PhoneAccountHandle registration entries. This is a simple verbatim
	* delegate for all the account handling methods on {@link TelecommManager} as implemented in
	* {@link TelecommServiceImpl}, with the notable exception that {@link TelecommServiceImpl} is
	* responsible for security checking to make sure that the caller has proper authority over
	* the {@code ComponentName}s they are declaring in their {@code PhoneAccountHandle}s.
	*
	* TODO(santoscordon): Replace this implementation with a proper database stored in a Telecomm
	* provider.
	*/
	final class PhoneAccountRegistrar {
	private static final String TELECOMM_PREFERENCES = "telecomm_prefs";
	private static final String PREFERENCE_PHONE_ACCOUNTS = "phone_accounts";

	private final Context mContext;
	private final State mState;

	PhoneAccountRegistrar(Context context) {
	mContext = context;
	mState = readState();
	}

	public PhoneAccountHandle getDefaultOutgoingPhoneAccount() {
	if (mState.defaultOutgoing != null) {
	// Return the registered outgoing default iff it still exists (we keep a sticky
	// default to survive account deletion and re-addition)
	for (int i = 0; i < mState.accounts.size(); i++) {
	if (mState.accounts.get(i).getAccountHandle().equals(mState.defaultOutgoing)) {
	return mState.defaultOutgoing;
	}
	}
	// At this point, there was a registered default but it has been deleted; proceed
	// as though there were no default
	}

	List<PhoneAccountHandle> enabled = getEnabledPhoneAccounts();
	switch (enabled.size()) {
	case 0:
	// There are no accounts, so there can be no default
	return null;
	case 1:
	// There is only one account, which is by definition the default
	return enabled.get(0);
	default:
	// There are multiple accounts with no selected default
	return null;
	}
	}

	public void setDefaultOutgoingPhoneAccount(PhoneAccountHandle accountHandle) {
	if (accountHandle == null) {
	// Asking to clear the default outgoing is a valid request
	mState.defaultOutgoing = null;
	} else {
	boolean found = false;
	for (PhoneAccount m : mState.accounts) {
	if (Objects.equals(accountHandle, m.getAccountHandle())) {
	found = true;
	break;
	}
	}

	if (!found) {
	Log.w(this, "Trying to set nonexistent default outgoing phone accountHandle %s",
	accountHandle);
	return;
	}

	mState.defaultOutgoing = accountHandle;
	}

	write();
	}

	public void setSimCallManager(PhoneAccountHandle callManager) {
	if (callManager != null) {
	PhoneAccount callManagerAccount = getPhoneAccount(callManager);
	if (callManagerAccount == null) {
	Log.d(this, "setSimCallManager: Nonexistent call manager: %s", callManager);
	return;
	} else if (!has(callManagerAccount, PhoneAccount.CAPABILITY_SIM_CALL_MANAGER)) {
	Log.d(this, "setSimCallManager: Not a call manager: %s", callManagerAccount);
	return;
	}
	}
	mState.simCallManager = callManager;
	write();
	}

	public PhoneAccountHandle getSimCallManager() {
	return mState.simCallManager;
	}

	public List<PhoneAccountHandle> getAllPhoneAccountHandles() {
	List<PhoneAccountHandle> accountHandles = new ArrayList<>();
	for (PhoneAccount m : mState.accounts) {
	accountHandles.add(m.getAccountHandle());
	}
	return accountHandles;
	}

	public List<PhoneAccount> getAllPhoneAccounts() {
	return new ArrayList<>(mState.accounts);
	}

	// TODO: Rename systemwide to "getCallProviderPhoneAccounts"?
	public List<PhoneAccountHandle> getEnabledPhoneAccounts() {
	return getCallProviderAccountHandles();
	}

	public PhoneAccount getPhoneAccount(PhoneAccountHandle handle) {
	for (PhoneAccount m : mState.accounts) {
	if (Objects.equals(handle, m.getAccountHandle())) {
	return m;
	}
	}
	return null;
	}

	// TODO: Should we implement an artificial limit for # of accounts associated with a single
	// ComponentName?
	public void registerPhoneAccount(PhoneAccount account) {
	account = hackFixBabelAccount(account);
	mState.accounts.add(account);
	// Search for duplicates and remove any that are found.
	for (int i = 0; i < mState.accounts.size() - 1; i++) {
	if (Objects.equals(
	account.getAccountHandle(), mState.accounts.get(i).getAccountHandle())) {
	// replace existing entry.
	mState.accounts.remove(i);
	break;
	}
	}

	write();
	}

	// STOPSHIP: Hack to edit the account registered by Babel so it shows up properly
	private PhoneAccount hackFixBabelAccount(PhoneAccount account) {
	String pkg = account.getAccountHandle().getComponentName().getPackageName();
	return "com.google.android.talk".equals(pkg)
	? new PhoneAccount(
	account.getAccountHandle(),
	account.getHandle(),
	account.getSubscriptionNumber(),
	PhoneAccount.CAPABILITY_SIM_CALL_MANAGER,
	account.getIconResId(),
	account.getLabel(),
	account.getShortDescription(),
	account.isVideoCallingSupported())
	: account;
	}

	public void unregisterPhoneAccount(PhoneAccountHandle accountHandle) {
	for (int i = 0; i < mState.accounts.size(); i++) {
	if (Objects.equals(accountHandle, mState.accounts.get(i).getAccountHandle())) {
	mState.accounts.remove(i);
	break;
	}
	}

	write();
	}

	public void clearAccounts(String packageName) {
	for (int i = 0; i < mState.accounts.size(); i++) {
	if (Objects.equals(
	packageName,
	mState.accounts.get(i).getAccountHandle()
	.getComponentName().getPackageName())) {
	mState.accounts.remove(i);
	}
	}

	write();
	}

	////////////////////////////////////////////////////////////////////////////////////////////////

	// TODO: Add a corresponding has(...) method to class PhoneAccount itself and remove this one
	// Return true iff the given account has all the specified capability flags
	static boolean has(PhoneAccount account, int capability) {
	return (account.getCapabilities() & capability) == capability;
	}

	private List<PhoneAccountHandle> getCallProviderAccountHandles() {
	List<PhoneAccountHandle> accountHandles = new ArrayList<>();
	for (PhoneAccount m : mState.accounts) {
	if (has(m, PhoneAccount.CAPABILITY_CALL_PROVIDER)) {
	accountHandles.add(m.getAccountHandle());
	}
	}
	return accountHandles;
	}

	/**
	* The state of this {@code PhoneAccountRegistrar}.
	*/
	private static class State {
	/**
	* The account selected by the user to be employed by default for making outgoing calls.
	* If the user has not made such a selection, then this is null.
	*/
	public PhoneAccountHandle defaultOutgoing = null;

	/**
	* A {@code PhoneAccount} having {@link PhoneAccount#CAPABILITY_SIM_CALL_MANAGER} which
	* manages and optimizes a user's PSTN SIM connections.
	*/
	public PhoneAccountHandle simCallManager;

	/**
	* The complete list of {@code PhoneAccount}s known to the Telecomm subsystem.
	*/
	public final List<PhoneAccount> accounts = new ArrayList<>();
	}

	////////////////////////////////////////////////////////////////////////////////////////////////
	//
	// State management
	//

	private void write() {
	writeState(mState);
	}

	private State readState() {
	try {
	String serialized = getPreferences().getString(PREFERENCE_PHONE_ACCOUNTS, null);
	Log.v(this, "read() obtained serialized state: %s", serialized);
	State state = serialized == null
	? new State()
	: deserializeState(serialized);
	Log.v(this, "read() obtained state: %s", state);
	return state;
	} catch (JSONException e) {
	Log.e(this, e, "read");
	return new State();
	}
	}

	private boolean writeState(State state) {
	try {
	Log.v(this, "write() writing state: %s", state);
	String serialized = serializeState(state);
	Log.v(this, "write() writing serialized state: %s", serialized);
	boolean success = getPreferences()
	.edit()
	.putString(PREFERENCE_PHONE_ACCOUNTS, serialized)
	.commit();
	Log.v(this, "serialized state was written with success = %b", success);
	return success;
	} catch (JSONException e) {
	Log.e(this, e, "write");
	return false;
	}
	}

	private SharedPreferences getPreferences() {
	return mContext.getSharedPreferences(TELECOMM_PREFERENCES, Context.MODE_PRIVATE);
	}

	private String serializeState(State s) throws JSONException {
	// TODO: If this is used in production, remove the indent (=> do not pretty print)
	return sStateJson.toJson(s).toString(2);
	}

	private State deserializeState(String s) throws JSONException {
	return sStateJson.fromJson(new JSONObject(new JSONTokener(s)));
	}

	////////////////////////////////////////////////////////////////////////////////////////////////
	//
	// JSON serialization
	//

	private interface Json<T> {
	JSONObject toJson(T o) throws JSONException;
	T fromJson(JSONObject json) throws JSONException;
	}

	private static final Json<State> sStateJson =
	new Json<State>() {
	private static final String DEFAULT_OUTGOING = "default_outgoing";
	private static final String SIM_CALL_MANAGER = "sim_call_manager";
	private static final String ACCOUNTS = "accounts";

	@Override
	public JSONObject toJson(State o) throws JSONException {
	JSONObject json = new JSONObject();
	if (o.defaultOutgoing != null) {
	json.put(DEFAULT_OUTGOING, sPhoneAccountHandleJson.toJson(o.defaultOutgoing));
	}
	if (o.simCallManager != null) {
	json.put(SIM_CALL_MANAGER, sPhoneAccountHandleJson.toJson(o.simCallManager));
	}
	JSONArray accounts = new JSONArray();
	for (PhoneAccount m : o.accounts) {
	accounts.put(sPhoneAccountJson.toJson(m));
	}
	json.put(ACCOUNTS, accounts);
	return json;
	}

	@Override
	public State fromJson(JSONObject json) throws JSONException {
	State s = new State();
	if (json.has(DEFAULT_OUTGOING)) {
	try {
	s.defaultOutgoing = sPhoneAccountHandleJson.fromJson(
	(JSONObject) json.get(DEFAULT_OUTGOING));
	} catch (Exception e) {
	Log.e(this, e, "Extracting PhoneAccountHandle");
	}
	}
	if (json.has(SIM_CALL_MANAGER)) {
	try {
	s.simCallManager = sPhoneAccountHandleJson.fromJson(
	(JSONObject) json.get(SIM_CALL_MANAGER));
	} catch (Exception e) {
	Log.e(this, e, "Extracting PhoneAccountHandle");
	}
	}
	if (json.has(ACCOUNTS)) {
	JSONArray accounts = (JSONArray) json.get(ACCOUNTS);
	for (int i = 0; i < accounts.length(); i++) {
	try {
	s.accounts.add(sPhoneAccountJson.fromJson(
	(JSONObject) accounts.get(i)));
	} catch (Exception e) {
	Log.e(this, e, "Extracting phone account");
	}
	}
	}
	return s;
	}
	};

	private static final Json<PhoneAccount> sPhoneAccountJson =
	new Json<PhoneAccount>() {
	private static final String ACCOUNT = "account";
	private static final String HANDLE = "handle";
	private static final String SUBSCRIPTION_NUMBER = "subscription_number";
	private static final String CAPABILITIES = "capabilities";
	private static final String ICON_RES_ID = "icon_res_id";
	private static final String LABEL = "label";
	private static final String SHORT_DESCRIPTION = "short_description";
	private static final String VIDEO_CALLING_SUPPORTED = "video_calling_supported";

	@Override
	public JSONObject toJson(PhoneAccount o) throws JSONException {
	return new JSONObject()
	.put(ACCOUNT, sPhoneAccountHandleJson.toJson(o.getAccountHandle()))
	.put(HANDLE, o.getHandle().toString())
	.put(SUBSCRIPTION_NUMBER, o.getSubscriptionNumber())
	.put(CAPABILITIES, o.getCapabilities())
	.put(ICON_RES_ID, o.getIconResId())
	.put(LABEL, o.getLabel())
	.put(SHORT_DESCRIPTION, o.getShortDescription())
	.put(VIDEO_CALLING_SUPPORTED, (Boolean) o.isVideoCallingSupported());
	}

	@Override
	public PhoneAccount fromJson(JSONObject json) throws JSONException {
	return new PhoneAccount(
	sPhoneAccountHandleJson.fromJson((JSONObject) json.get(ACCOUNT)),
	Uri.parse((String) json.get(HANDLE)),
	(String) json.get(SUBSCRIPTION_NUMBER),
	(int) json.get(CAPABILITIES),
	(int) json.get(ICON_RES_ID),
	(String) json.get(LABEL),
	(String) json.get(SHORT_DESCRIPTION),
	(Boolean) json.get(VIDEO_CALLING_SUPPORTED));
	}
	};

	private static final Json<PhoneAccountHandle> sPhoneAccountHandleJson =
	new Json<PhoneAccountHandle>() {
	private static final String COMPONENT_NAME = "component_name";
	private static final String ID = "id";

	@Override
	public JSONObject toJson(PhoneAccountHandle o) throws JSONException {
	return new JSONObject()
	.put(COMPONENT_NAME, o.getComponentName().flattenToString())
	.put(ID, o.getId());
	}

	@Override
	public PhoneAccountHandle fromJson(JSONObject json) throws JSONException {
	return new PhoneAccountHandle(
	ComponentName.unflattenFromString((String) json.get(COMPONENT_NAME)),
	(String) json.get(ID));
	}
	};
	}