public static CityObj[] loadCitiesDataBase(Context c) {
final Collator collator = Collator.getInstance();
Resources r = c.getResources();
// Read strings array of name,timezone, id
// make sure the list are the same length
String[] cities = r.getStringArray(R.array.cities_names);
String[] timezones = r.getStringArray(R.array.cities_tz);
String[] ids = r.getStringArray(R.array.cities_id);
if (cities.length != timezones.length || ids.length != cities.length) {
Log.wtf("City lists sizes are not the same, cannot use the data");
return null;
}
CityObj[] tempList = new CityObj[cities.length];
for (int i = 0; i < cities.length; i++) {
tempList[i] = new CityObj(cities[i], timezones[i], ids[i]);
}
// Sort alphabetically
Arrays.sort(
tempList,
new Comparator<CityObj>() {
@Override
public int compare(CityObj c1, CityObj c2) {
Comparator<CityObj> mCollator;
return collator.compare(c1.mCityName, c2.mCityName);
}
});
return tempList;
}
/**
* Adds two query parameters into the Uri, namely the language code and the version code of the
* app's package as gotten via the context.
*
* @return the uri with added query parameters
*/
private static Uri uriWithAddedParameters(Context context, Uri baseUri) {
Uri.Builder builder = baseUri.buildUpon();
// Add in the preferred language
builder.appendQueryParameter(PARAM_LANGUAGE_CODE, Locale.getDefault().toString());
// Add in the package version code
if (sCachedVersionCode == null) {
// There is no cached version code, so try to get it from the package manager.
try {
// cache the version code
PackageInfo info = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
sCachedVersionCode = Integer.toString(info.versionCode);
// append the version code to the uri
builder.appendQueryParameter(PARAM_VERSION, sCachedVersionCode);
} catch (NameNotFoundException e) {
// Cannot find the package name, so don't add in the version parameter
// This shouldn't happen.
Log.wtf("Invalid package name for context " + e);
}
} else {
builder.appendQueryParameter(PARAM_VERSION, sCachedVersionCode);
}
// Build the full uri and return it
return builder.build();
}
/** Setup to find out when the quarter-hour changes (e.g. Kathmandu is GMT+5:45) * */
private static long getAlarmOnQuarterHour() {
Calendar nextQuarter = Calendar.getInstance();
// Set 1 second to ensure quarter-hour threshold passed.
nextQuarter.set(Calendar.SECOND, 1);
int minute = nextQuarter.get(Calendar.MINUTE);
nextQuarter.add(Calendar.MINUTE, 15 - (minute % 15));
long alarmOnQuarterHour = nextQuarter.getTimeInMillis();
if (0 >= (alarmOnQuarterHour - System.currentTimeMillis())
|| (alarmOnQuarterHour - System.currentTimeMillis()) > 901000) {
Log.wtf("quarterly alarm calculation error");
}
return alarmOnQuarterHour;
}
private void conference(String callId1, String callId2) {
Log.d(this, "conference %s, %s", callId1, callId2);
// Attempt to get second connection or conference.
Connection connection2 = findConnectionForAction(callId2, "conference");
Conference conference2 = getNullConference();
if (connection2 == getNullConnection()) {
conference2 = findConferenceForAction(callId2, "conference");
if (conference2 == getNullConference()) {
Log.w(this, "Connection2 or Conference2 missing in conference request %s.", callId2);
return;
}
}
// Attempt to get first connection or conference and perform merge.
Connection connection1 = findConnectionForAction(callId1, "conference");
if (connection1 == getNullConnection()) {
Conference conference1 = findConferenceForAction(callId1, "addConnection");
if (conference1 == getNullConference()) {
Log.w(this, "Connection1 or Conference1 missing in conference request %s.", callId1);
} else {
// Call 1 is a conference.
if (connection2 != getNullConnection()) {
// Call 2 is a connection so merge via call 1 (conference).
conference1.onMerge(connection2);
} else {
// Call 2 is ALSO a conference; this should never happen.
Log.wtf(
this,
"There can only be one conference and an attempt was made to "
+ "merge two conferences.");
return;
}
}
} else {
// Call 1 is a connection.
if (conference2 != getNullConference()) {
// Call 2 is a conference, so merge via call 2.
conference2.onMerge(connection1);
} else {
// Call 2 is a connection, so merge together.
onConference(connection1, connection2);
}
}
}
/** Gets the call state label based on the state of the call and cause of disconnect */
private String getCallStateLabelFromState(int state, Call.DisconnectCause cause) {
final Context context = getView().getContext();
String callStateLabel = null; // Label to display as part of the call banner
if (Call.State.IDLE == state) {
// "Call state" is meaningless in this state.
} else if (Call.State.ACTIVE == state) {
// We normally don't show a "call state label" at all in
// this state (but see below for some special cases).
} else if (Call.State.ONHOLD == state) {
callStateLabel = context.getString(R.string.card_title_on_hold);
} else if (Call.State.DIALING == state) {
callStateLabel = context.getString(R.string.card_title_dialing);
} else if (Call.State.REDIALING == state) {
callStateLabel = context.getString(R.string.card_title_redialing);
} else if (Call.State.INCOMING == state || Call.State.CALL_WAITING == state) {
callStateLabel = context.getString(R.string.card_title_incoming_call);
} else if (Call.State.DISCONNECTING == state) {
// While in the DISCONNECTING state we display a "Hanging up"
// message in order to make the UI feel more responsive. (In
// GSM it's normal to see a delay of a couple of seconds while
// negotiating the disconnect with the network, so the "Hanging
// up" state at least lets the user know that we're doing
// something. This state is currently not used with CDMA.)
callStateLabel = context.getString(R.string.card_title_hanging_up);
} else if (Call.State.DISCONNECTED == state) {
callStateLabel = getCallFailedString(cause);
} else {
Log.wtf(this, "updateCallStateWidgets: unexpected call: " + state);
}
return callStateLabel;
}
/**
* Called when the UI begins or ends. Starts the callstate callbacks if the UI just began.
* Attempts to tear down everything if the UI just ended. See #tearDown for more insight on the
* tear-down process.
*/
public void setActivity(InCallActivity inCallActivity) {
boolean updateListeners = false;
boolean doAttemptCleanup = false;
if (inCallActivity != null) {
if (mInCallActivity == null) {
updateListeners = true;
Log.i(this, "UI Initialized");
} else if (mInCallActivity != inCallActivity) {
Log.wtf(this, "Setting a second activity before destroying the first.");
} else {
// since setActivity is called onStart(), it can be called multiple times.
// This is fine and ignorable, but we do not want to update the world every time
// this happens (like going to/from background) so we do not set updateListeners.
}
mInCallActivity = inCallActivity;
// By the time the UI finally comes up, the call may already be disconnected.
// If that's the case, we may need to show an error dialog.
if (mCallList != null && mCallList.getDisconnectedCall() != null) {
maybeShowErrorDialogOnDisconnect(mCallList.getDisconnectedCall());
}
// When the UI comes up, we need to first check the in-call state.
// If we are showing NO_CALLS, that means that a call probably connected and
// then immediately disconnected before the UI was able to come up.
// If we dont have any calls, start tearing down the UI instead.
// NOTE: This code relies on {@link #mInCallActivity} being set so we run it after
// it has been set.
if (mInCallState == InCallState.NO_CALLS) {
Log.i(this, "UI Intialized, but no calls left. shut down.");
attemptFinishActivity();
return;
}
} else {
Log.i(this, "UI Destroyed)");
updateListeners = true;
mInCallActivity = null;
// We attempt cleanup for the destroy case but only after we recalculate the state
// to see if we need to come back up or stay shut down. This is why we do the cleanup
// after the call to onCallListChange() instead of directly here.
doAttemptCleanup = true;
}
// Messages can come from the telephony layer while the activity is coming up
// and while the activity is going down. So in both cases we need to recalculate what
// state we should be in after they complete.
// Examples: (1) A new incoming call could come in and then get disconnected before
// the activity is created.
// (2) All calls could disconnect and then get a new incoming call before the
// activity is destroyed.
//
// b/1122139 - We previously had a check for mServiceConnected here as well, but there are
// cases where we need to recalculate the current state even if the service in not
// connected. In particular the case where startOrFinish() is called while the app is
// already finish()ing. In that case, we skip updating the state with the knowledge that
// we will check again once the activity has finished. That means we have to recalculate the
// state here even if the service is disconnected since we may not have finished a state
// transition while finish()ing.
if (updateListeners) {
onCallListChange(mCallList);
}
if (doAttemptCleanup) {
attemptCleanup();
}
}