diff options
Diffstat (limited to 'SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android')
80 files changed, 14880 insertions, 0 deletions
diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/MainApp.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/MainApp.java new file mode 100644 index 000000000..a51084b50 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/MainApp.java @@ -0,0 +1,141 @@ +package com.ford.syncV4.android; + +import android.app.Application; +import android.content.Context; +import android.content.Intent; +import android.os.Handler; +import android.os.Looper; +import android.util.Log; + +import com.ford.syncV4.android.manager.LastUsedHashIdsManager; +import com.ford.syncV4.android.service.IProxyServiceBinder; +import com.ford.syncV4.android.service.IProxyServiceConnection; +import com.ford.syncV4.android.service.ProxyService; +import com.ford.syncV4.android.service.ProxyServiceBinder; +import com.ford.syncV4.android.service.ProxyServiceConnectionProxy; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 1/29/14 + * Time: 4:31 PM + */ +public class MainApp extends Application implements IProxyServiceConnection { + + private static final String LOG_TAG = "SyncProxyTester"; + private static volatile MainApp sInstance = null; + + private final ProxyServiceConnectionProxy mProxyServiceConnectionProxy = + new ProxyServiceConnectionProxy(this); + private ProxyService mBoundProxyService; + private IProxyServiceBinder mProxyServiceBinder; + /** + * This manager keep last used hash id's which are in use at the + * {@link com.ford.syncV4.proxy.rpc.RegisterAppInterface#getHashID()} + */ + private LastUsedHashIdsManager mLastUsedHashIdsManager; + private final Handler mUIHandler = new Handler(Looper.getMainLooper()); + + public MainApp() { + super(); + sInstance = this; + + mLastUsedHashIdsManager = new LastUsedHashIdsManager(); + } + + /** + * Double-checked singleton fetching + * @return + */ + public static MainApp getInstance() { + if (sInstance == null) { + synchronized(MainApp.class) { + if (sInstance == null) { + new MainApp(); + } + } + } + return sInstance; + } + + @Override + public void onCreate() { + super.onCreate(); + + Log.i(LOG_TAG, MainApp.class.getSimpleName() + " On Create, processors: " + + Runtime.getRuntime().availableProcessors()); + } + + @Override + public void onProxyServiceConnected(ProxyServiceBinder service) { + Log.i(LOG_TAG, MainApp.class.getSimpleName() + " ProxyService connected " + service); + mBoundProxyService = service.getService(); + if (mProxyServiceBinder != null) { + mProxyServiceBinder.onServiceBindComplete(); + } + } + + @Override + public void onProxyServiceDisconnected() { + Log.i(LOG_TAG, MainApp.class.getSimpleName() + " ProxyService disconnected"); + mBoundProxyService = null; + } + + public void runInUIThread(Runnable r) { + mUIHandler.post(r); + } + + public void exitApp() { + android.os.Process.killProcess(android.os.Process.myPid()); + } + + /** + * Return {@link com.ford.syncV4.android.manager.LastUsedHashIdsManager} reference + * + * @return {@link com.ford.syncV4.android.manager.LastUsedHashIdsManager} + */ + public LastUsedHashIdsManager getLastUsedHashIdsManager() { + return mLastUsedHashIdsManager; + } + + public ProxyService getBoundProxyService() { + return mBoundProxyService; + } + + public void bindProxyToMainApp(IProxyServiceBinder binderCallback) { + mProxyServiceBinder = binderCallback; + bindProxyService(this, mProxyServiceConnectionProxy); + } + + public void unbindProxyFromMainApp() { + unbindProxyService(this, mProxyServiceConnectionProxy); + } + + private void bindProxyService(Context context, ProxyServiceConnectionProxy connectionProxy) { + Log.i(LOG_TAG, MainApp.class.getSimpleName() + " Bind ProxyService, connection proxy: " + + connectionProxy); + context.bindService(new Intent(context, ProxyService.class), connectionProxy, + BIND_AUTO_CREATE); + } + + private void unbindProxyService(Context context, ProxyServiceConnectionProxy connectionProxy) { + if (!connectionProxy.isConnected()) { + Log.v(LOG_TAG, MainApp.class.getSimpleName() + " ServiceConnection is not connected, " + + "ignoring unbindService: " + connectionProxy); + return; + } + try { + Log.i(LOG_TAG, MainApp.class.getSimpleName() + " Unbind Service, " + + "connection proxy: " + connectionProxy); + context.unbindService(connectionProxy); + } catch (IllegalArgumentException iae) { + // sometimes this exception is still thrown, in spite of isConnected() check above + // simply ignore this exception + Log.w(LOG_TAG, MainApp.class.getSimpleName() + " Unbind IllegalArgumentException: " + + iae); + } catch (Exception e) { + Log.e(LOG_TAG, MainApp.class.getSimpleName() + " Error unbinding from connection: " + + connectionProxy, e); + } + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/AddCommandDialog.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/AddCommandDialog.java new file mode 100644 index 000000000..ac48ac3c4 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/AddCommandDialog.java @@ -0,0 +1,145 @@ +package com.ford.syncV4.android.activity; + +import android.app.AlertDialog; +import android.app.Dialog; +import android.app.DialogFragment; +import android.content.Context; +import android.content.DialogInterface; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.ArrayAdapter; +import android.widget.CheckBox; +import android.widget.EditText; +import android.widget.Spinner; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.constants.SyncSubMenu; +import com.ford.syncV4.proxy.RPCRequestFactory; +import com.ford.syncV4.proxy.rpc.AddCommand; +import com.ford.syncV4.proxy.rpc.Image; +import com.ford.syncV4.proxy.rpc.MenuParams; +import com.ford.syncV4.proxy.rpc.enums.ImageType; + +import java.util.Arrays; +import java.util.Vector; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 2/21/14 + * Time: 10:09 AM + */ +public class AddCommandDialog extends DialogFragment { + + private static final String LOG_TAG = "AddCommandDialog"; + + private static int sItemCmdId = 1; + + public static AddCommandDialog newInstance() { + AddCommandDialog sendAddCommandDialog = new AddCommandDialog(); + return sendAddCommandDialog; + } + + @Override + public Dialog onCreateDialog(Bundle savedInstanceState) { + final Context mContext = getActivity(); + LayoutInflater inflater = (LayoutInflater) mContext.getSystemService( + Context.LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.addcommand, + (ViewGroup) getActivity().findViewById(R.id.itemRoot)); + + final EditText editCmdID = (EditText) layout.findViewById(R.id.addcommand_commandID); + final CheckBox chkUseCommandName = (CheckBox) layout.findViewById(R.id.addcommand_useCommandName); + final EditText er = (EditText) layout.findViewById(R.id.addcommand_commandName); + final CheckBox chkUseVrSynonyms = (CheckBox) layout.findViewById(R.id.addcommand_useVRSynonyms); + final EditText editVrSynonyms = (EditText) layout.findViewById(R.id.addcommand_vrSynonym); + final CheckBox chkUseMenuParams = (CheckBox) layout.findViewById(R.id.addcommand_useMenuParams); + final CheckBox chkUseParentID = (CheckBox) layout.findViewById(R.id.addcommand_useParentID); + final Spinner s = (Spinner) layout.findViewById(R.id.addcommand_availableSubmenus); + s.setAdapter(((SyncProxyTester) getActivity()).getSubMenuAdapter()); + final CheckBox chkUseMenuPos = (CheckBox) layout.findViewById(R.id.addcommand_useMenuPos); + final EditText editMenuPos = (EditText) layout.findViewById(R.id.addcommand_menuPos); + final CheckBox chkUseIcon = (CheckBox) layout.findViewById(R.id.addcommand_useIcon); + final EditText editIconValue = (EditText) layout.findViewById(R.id.addcommand_iconValue); + final Spinner spnIconType = (Spinner) layout.findViewById(R.id.addcommand_iconType); + + // set suggested value + editCmdID.setText(String.valueOf(sItemCmdId++)); + + ArrayAdapter<ImageType> imageTypeArrayAdapter = + ((SyncProxyTester) getActivity()).getImageTypeAdapter(); + spnIconType.setAdapter(imageTypeArrayAdapter); + spnIconType.setSelection(imageTypeArrayAdapter.getPosition(ImageType.DYNAMIC)); + + return new AlertDialog.Builder(mContext) + .setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + String cmdIDString = editCmdID.getText().toString(); + int cmdID; + try { + cmdID = Integer.parseInt(cmdIDString); + } catch (NumberFormatException e) { + SafeToast.showToastAnyThread("Couldn't parse number " + cmdIDString); + return; + } + + int pos = -1; + if (chkUseMenuPos.isChecked()) { + String posString = editMenuPos.getText().toString(); + try { + pos = Integer.parseInt(posString); + } catch (NumberFormatException e) { + SafeToast.showToastAnyThread("Couldn't parse number " + posString); + return; + } + } + + AddCommand addCommand = RPCRequestFactory.buildAddCommand(); + addCommand.setCorrelationID(((SyncProxyTester) getActivity()) + .getCorrelationid()); + addCommand.setCmdID(cmdID); + + if (chkUseMenuParams.isChecked()) { + MenuParams menuParams = new MenuParams(); + if (chkUseCommandName.isChecked()) { + String menuNameValue = er.getText().toString(); + //Log.d(LOG_TAG, "AddCommand MenuName:" + menuNameValue); + menuParams.setMenuName(menuNameValue); + } + if (chkUseMenuPos.isChecked()) { + menuParams.setPosition(pos); + } + if (chkUseParentID.isChecked()) { + SyncSubMenu sm = (SyncSubMenu) s.getSelectedItem(); + if (sm != null) { + menuParams.setParentID(sm.getSubMenuId()); + } + } + addCommand.setMenuParams(menuParams); + } + + if (chkUseVrSynonyms.isChecked()) { + addCommand.setVrCommands(new Vector<String>( + Arrays.asList(editVrSynonyms.getText() + .toString().split(SyncProxyTester.JOIN_STRING)))); + } + + if (chkUseIcon.isChecked()) { + Image icon = new Image(); + icon.setValue(editIconValue.getText().toString()); + icon.setImageType((ImageType) spnIconType.getSelectedItem()); + addCommand.setCmdIcon(icon); + } + + ((SyncProxyTester) getActivity()).onAddCommandDialogResult(addCommand); + } + }) + .setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }).setView(layout).show(); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/AddSubMenuDialog.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/AddSubMenuDialog.java new file mode 100644 index 000000000..7c3b5281d --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/AddSubMenuDialog.java @@ -0,0 +1,102 @@ +package com.ford.syncV4.android.activity; + +import android.app.AlertDialog; +import android.app.Dialog; +import android.app.DialogFragment; +import android.content.Context; +import android.content.DialogInterface; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.CheckBox; +import android.widget.EditText; +import android.widget.Toast; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.constants.SyncSubMenu; +import com.ford.syncV4.proxy.RPCRequestFactory; +import com.ford.syncV4.proxy.rpc.AddSubMenu; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 2/24/14 + * Time: 10:35 AM + */ +public class AddSubMenuDialog extends DialogFragment { + + private static final String LOG_TAG = "AddSubMenuDialog"; + + private static int sSubMenuCmdID = 1000; + + public static AddSubMenuDialog newInstance() { + AddSubMenuDialog addSubMenuDialog = new AddSubMenuDialog(); + return addSubMenuDialog; + } + + @Override + public Dialog onCreateDialog(Bundle savedInstanceState) { + final Context mContext = getActivity(); + LayoutInflater inflater = (LayoutInflater) mContext.getSystemService( + Context.LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.addsubmenu, + (ViewGroup) getActivity().findViewById(R.id.itemRoot)); + + final EditText editMenuName = (EditText) layout.findViewById(R.id.addsubmenu_menuName); + final EditText editMenuID = (EditText) layout.findViewById(R.id.addsubmenu_menuID); + final CheckBox chkUseMenuPos = (CheckBox) layout.findViewById(R.id.addsubmenu_useMenuPos); + final EditText editMenuPos = (EditText) layout.findViewById(R.id.addsubmenu_menuPos); + + // set suggested value + editMenuID.setText(String.valueOf(sSubMenuCmdID++)); + + return new AlertDialog.Builder(mContext) + .setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + String subMenuIDString = editMenuID.getText().toString(); + int subMenuID = -1; + try { + subMenuID = Integer.parseInt(subMenuIDString); + } catch (NumberFormatException e) { + Toast.makeText(mContext, "Couldn't parse number " + subMenuIDString, + Toast.LENGTH_LONG).show(); + return; + } + + int pos = -1; + if (chkUseMenuPos.isChecked()) { + String posString = editMenuPos.getText().toString(); + try { + pos = Integer.parseInt(posString); + } catch (NumberFormatException e) { + Toast.makeText(mContext, "Couldn't parse number " + posString, + Toast.LENGTH_LONG).show(); + return; + } + } + + AddSubMenu addSubMenu = RPCRequestFactory.buildAddSubMenu(); + addSubMenu.setCorrelationID(((SyncProxyTester) getActivity()) + .getCorrelationid()); + + SyncSubMenu subMenu = new SyncSubMenu(); + subMenu.setName(editMenuName.getText().toString()); + subMenu.setSubMenuId(subMenuID); + addSubMenu.setMenuID(subMenu.getSubMenuId()); + addSubMenu.setMenuName(subMenu.getName()); + if (chkUseMenuPos.isChecked()) { + addSubMenu.setPosition(pos); + } + ((SyncProxyTester) getActivity()).onAddSubMenuDialogResult(addSubMenu, + subMenu); + } + }) + .setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }) + .setView(layout).show(); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/AppSetUpDialog.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/AppSetUpDialog.java new file mode 100644 index 000000000..82e962667 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/AppSetUpDialog.java @@ -0,0 +1,242 @@ +package com.ford.syncV4.android.activity; + +import android.app.AlertDialog; +import android.app.Dialog; +import android.app.DialogFragment; +import android.content.Context; +import android.content.DialogInterface; +import android.content.SharedPreferences; +import android.os.Build; +import android.os.Bundle; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.ArrayAdapter; +import android.widget.CheckBox; +import android.widget.CompoundButton; +import android.widget.EditText; +import android.widget.LinearLayout; +import android.widget.RadioGroup; +import android.widget.Spinner; +import android.widget.TextView; +import android.widget.ToggleButton; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.constants.Const; +import com.ford.syncV4.android.manager.AppPreferencesManager; +import com.ford.syncV4.android.service.ProxyService; +import com.ford.syncV4.proxy.SyncProxyBase; +import com.ford.syncV4.proxy.rpc.enums.Language; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 12/24/13 + * Time: 1:32 PM + */ + +/** + * Shows a dialog where the user can select connection features (media flag, app name, language, + * HMI language, transport settings, etc ...). + * Starts the proxy after selecting. + */ +public class AppSetUpDialog extends DialogFragment { + + private static final String LOG_TAG = "AppSetUpDialog"; + + public static AppSetUpDialog newInstance() { + AppSetUpDialog appSetupDialog = new AppSetUpDialog(); + return appSetupDialog; + } + + @Override + public Dialog onCreateDialog(Bundle savedInstanceState) { + Context context = getActivity(); + LayoutInflater inflater = (LayoutInflater) context.getSystemService( + getActivity().LAYOUT_INFLATER_SERVICE); + final View view = inflater.inflate(R.layout.selectprotocol, + (ViewGroup) getActivity().findViewById(R.id.selectprotocol_Root)); + + ArrayAdapter<Language> langAdapter = new ArrayAdapter<Language>(getActivity(), + android.R.layout.simple_spinner_item, Language.values()); + langAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + final CheckBox policyFileUpdateAutoReplayView = + (CheckBox) view.findViewById(R.id.policy_file_update_auto_replay_view); + policyFileUpdateAutoReplayView.setChecked(AppPreferencesManager.getPolicyTableUpdateAutoReplay()); + policyFileUpdateAutoReplayView.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { + AppPreferencesManager.setPolicyTableUpdateAutoReplay(isChecked); + } + }); + final CheckBox isHearBeat = (CheckBox) view.findViewById(R.id.heartbeat); + final CheckBox mediaCheckBox = (CheckBox) view.findViewById(R.id.selectprotocol_checkMedia); + final CheckBox naviCheckBox = (CheckBox) view.findViewById( + R.id.selectprotocol_checkMobileNavi); + final RadioGroup videoSourceGroup = (RadioGroup) view.findViewById( + R.id.selectprotocol_radioGroupVideoSource); + final EditText appNameEditText = (EditText) view.findViewById(R.id.selectprotocol_appName); + final Spinner langSpinner = (Spinner) view.findViewById(R.id.selectprotocol_lang); + final Spinner hmiLangSpinner = (Spinner) view.findViewById(R.id.selectprotocol_hmiLang); + final RadioGroup transportGroup = (RadioGroup) view.findViewById( + R.id.selectprotocol_radioGroupTransport); + final EditText ipAddressEditText = (EditText) view.findViewById(R.id.selectprotocol_ipAddr); + final EditText tcpPortEditText = (EditText) view.findViewById(R.id.selectprotocol_tcpPort); + final LinearLayout nsdUseLayout = (LinearLayout) view.findViewById(R.id.nsd_use_layout); + final LinearLayout ipAddressLayout = (LinearLayout) view.findViewById(R.id.ip_address_layout); + final LinearLayout portLayout = (LinearLayout) view.findViewById(R.id.port_layout); + final ToggleButton mNSDUseToggle = (ToggleButton) view.findViewById(R.id.nsd_toggle_btn); + + final boolean mIsNSDSupported = Build.VERSION.SDK_INT >= Const.JELLYBEAN_API_LEVEL; + + final CheckBox autoSetAppIconCheckBox = (CheckBox) view.findViewById( + R.id.selectprotocol_checkAutoSetAppIcon); + + ipAddressLayout.setVisibility(View.GONE); + portLayout.setVisibility(View.GONE); + nsdUseLayout.setVisibility(View.GONE); + + transportGroup.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() { + @Override + public void onCheckedChanged(RadioGroup group, int checkedId) { + boolean transportOptionsEnabled = checkedId == R.id.selectprotocol_radioWiFi; + ipAddressLayout.setVisibility(transportOptionsEnabled ? View.VISIBLE : View.GONE); + portLayout.setVisibility(transportOptionsEnabled ? View.VISIBLE : View.GONE); + nsdUseLayout.setVisibility(transportOptionsEnabled ? View.VISIBLE : View.GONE); + if (!mIsNSDSupported) { + showNSDUnsupportedView(view); + } + } + }); + + langSpinner.setAdapter(langAdapter); + hmiLangSpinner.setAdapter(langAdapter); + + // display current configs + final SharedPreferences prefs = getActivity().getSharedPreferences(Const.PREFS_NAME, 0); + boolean isMedia = prefs.getBoolean(Const.PREFS_KEY_ISMEDIAAPP, + Const.PREFS_DEFAULT_ISMEDIAAPP); + boolean isNavi = prefs.getBoolean(Const.PREFS_KEY_ISNAVIAPP, + Const.PREFS_DEFAULT_ISNAVIAPP); + int videoSource = prefs.getInt(Const.PREFS_KEY_NAVI_VIDEOSOURCE, + Const.PREFS_DEFAULT_NAVI_VIDEOSOURCE); + String appName = prefs.getString(Const.PREFS_KEY_APPNAME, + Const.PREFS_DEFAULT_APPNAME); + Language lang = Language.valueOf(prefs.getString(Const.PREFS_KEY_LANG, + Const.PREFS_DEFAULT_LANG)); + Language hmiLang = Language.valueOf(prefs.getString( + Const.PREFS_KEY_HMILANG, Const.PREFS_DEFAULT_HMILANG)); + int transportType = prefs.getInt( + Const.Transport.PREFS_KEY_TRANSPORT_TYPE, + Const.Transport.PREFS_DEFAULT_TRANSPORT_TYPE); + String ipAddress = prefs.getString( + Const.Transport.PREFS_KEY_TRANSPORT_IP, + Const.Transport.PREFS_DEFAULT_TRANSPORT_IP); + int tcpPort = prefs.getInt(Const.Transport.PREFS_KEY_TRANSPORT_PORT, + Const.Transport.PREFS_DEFAULT_TRANSPORT_PORT); + + boolean autoSetAppIcon = prefs.getBoolean( + Const.PREFS_KEY_AUTOSETAPPICON, + Const.PREFS_DEFAULT_AUTOSETAPPICON); + + mediaCheckBox.setChecked(isMedia); + naviCheckBox.setChecked(isNavi); + appNameEditText.setText(appName); + langSpinner.setSelection(langAdapter.getPosition(lang)); + hmiLangSpinner.setSelection(langAdapter.getPosition(hmiLang)); + ipAddressEditText.setText(ipAddress); + tcpPortEditText.setText(String.valueOf(tcpPort)); + mNSDUseToggle.setChecked(prefs.getBoolean(Const.Transport.PREFS_KEY_IS_NSD, false)); + autoSetAppIconCheckBox.setChecked(autoSetAppIcon); + + int groupCheck = R.id.selectprotocol_radioUSB; + switch (transportType) { + case Const.Transport.KEY_TCP: + groupCheck = R.id.selectprotocol_radioWiFi; + break; + case Const.Transport.KEY_BLUETOOTH: + groupCheck = R.id.selectprotocol_radioBT; + break; + } + transportGroup.check(groupCheck); + + videoSourceGroup.check(videoSource == Const.KEY_VIDEOSOURCE_MP4 ? + R.id.selectprotocol_radioSourceMP4 : + R.id.selectprotocol_radioSourceH264); + + return new AlertDialog.Builder(context) + .setTitle(getString(R.string.app_setup_dialog_title)) + .setCancelable(false) + .setPositiveButton("OK", new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, int which) { + boolean isMedia = mediaCheckBox.isChecked(); + boolean isNavi = naviCheckBox.isChecked(); + int videoSource = (videoSourceGroup.getCheckedRadioButtonId() == + R.id.selectprotocol_radioSourceMP4 ? Const.KEY_VIDEOSOURCE_MP4 : + Const.KEY_VIDEOSOURCE_H264); + String appName = appNameEditText.getText().toString(); + String lang = ((Language) langSpinner.getSelectedItem()).name(); + String hmiLang = ((Language) hmiLangSpinner.getSelectedItem()).name(); + int transportType = Const.Transport.KEY_USB; + switch (transportGroup.getCheckedRadioButtonId()) { + case R.id.selectprotocol_radioWiFi: + transportType = Const.Transport.KEY_TCP; + break; + case R.id.selectprotocol_radioBT: + transportType = Const.Transport.KEY_BLUETOOTH; + break; + } + String ipAddress = ipAddressEditText.getText().toString(); + int tcpPort = Integer.parseInt(tcpPortEditText.getText().toString()); + + boolean autoSetAppIcon = autoSetAppIconCheckBox.isChecked(); + + boolean mNSDPrefValue = mIsNSDSupported && mNSDUseToggle.isChecked(); + // save the configs + boolean success = prefs + .edit() + .putBoolean(Const.PREFS_KEY_ISMEDIAAPP, isMedia) + .putBoolean(Const.PREFS_KEY_ISNAVIAPP, isNavi) + .putBoolean(Const.Transport.PREFS_KEY_IS_NSD, mNSDPrefValue) + .putInt(Const.PREFS_KEY_NAVI_VIDEOSOURCE, videoSource) + .putString(Const.PREFS_KEY_APPNAME, appName) + .putString(Const.PREFS_KEY_LANG, lang) + .putString(Const.PREFS_KEY_HMILANG, hmiLang) + .putInt(Const.Transport.PREFS_KEY_TRANSPORT_TYPE, transportType) + .putString( + Const.Transport.PREFS_KEY_TRANSPORT_IP, + ipAddress) + .putInt(Const.Transport.PREFS_KEY_TRANSPORT_PORT, tcpPort) + + .putBoolean(Const.PREFS_KEY_AUTOSETAPPICON, + autoSetAppIcon).commit(); + if (!success) { + Log.w(LOG_TAG, "Can't save selected protocol properties"); + } + + setupHeartbeat(isHearBeat); + ((SyncProxyTester) getActivity()).onSetUpDialogResult(); + } + }).setView(view).show(); + } + + private void setupHeartbeat(CheckBox isHearBeat) { + if (isHearBeat.isChecked()) { + SyncProxyBase.setHeartBeatInterval(ProxyService.HEARTBEAT_INTERVAL); + } else { + SyncProxyBase.setHeartBeatInterval(ProxyService.HEARTBEAT_INTERVAL_MAX); + } + } + + private void showNSDUnsupportedView(View view) { + TextView mNSDUnsupportedView = (TextView) view.findViewById(R.id.nsd_unsupported_api_label_view); + TextView mNSDLabelView = (TextView) view.findViewById(R.id.nsd_label_view); + ToggleButton mNSDToggleButtonView = (ToggleButton) view.findViewById(R.id.nsd_toggle_btn); + + mNSDLabelView.setEnabled(false); + mNSDToggleButtonView.setEnabled(false); + mNSDUnsupportedView.setVisibility(View.VISIBLE); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/ChoiceAdapter.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/ChoiceAdapter.java new file mode 100644 index 000000000..9cef7dd75 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/ChoiceAdapter.java @@ -0,0 +1,97 @@ +package com.ford.syncV4.android.activity; + +import android.content.Context; +import android.view.View; +import android.widget.ImageButton; +import android.widget.TextView; +import android.widget.TwoLineListItem; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.utils.StringUtils; +import com.ford.syncV4.proxy.rpc.Choice; +import com.ford.syncV4.proxy.rpc.Image; +import com.ford.syncV4.proxy.rpc.enums.ImageType; + +import java.util.Vector; + +/** + * Created by enikolsky on 2013-11-25. + */ +public class ChoiceAdapter extends RPCStructAdapter<Choice> { + public ChoiceAdapter(Context context, Vector<Choice> objects, + int maxObjectsNumber) { + super(context, objects, maxObjectsNumber); + } + + @Override + protected String titleForAddRow() { + return "Add choice"; + } + + @Override + protected void fillItem(TwoLineListItem item, int position) { + final Choice choice = getItem(position); + TextView text1 = item.getText1(); + TextView text2 = item.getText2(); + + ImageButton btnDelete = + (ImageButton) item.findViewById(R.id.rpcstructrow_deleteButton); + btnDelete.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + objects.remove(choice); + notifyDataSetChanged(); + } + }); + + StringBuilder sb1 = new StringBuilder(); + sb1.append("#").append(choice.getChoiceID()).append(": "); + sb1.append("\"").append(choice.getMenuName()).append("\""); + + final Vector<String> vrCommands = choice.getVrCommands(); + if (vrCommands != null) { + sb1.append(" (") + .append(StringUtils.joinStrings(vrCommands)) + .append(")"); + } + + sb1.append(", ").append(imageToString(choice.getImage())); + text1.setText(sb1.toString()); + + StringBuilder sb2 = new StringBuilder(); + final String secondaryText = choice.getSecondaryText(); + if (secondaryText != null) { + sb2.append("\"").append(secondaryText).append("\", "); + } + + final String tertiaryText = choice.getTertiaryText(); + if (tertiaryText != null) { + sb2.append("\"").append(tertiaryText).append("\", "); + } + + sb2.append(", ").append(imageToString(choice.getSecondaryImage())); + text2.setText(sb2.toString()); + } + + private String imageToString(Image image) { + if (image == null) { + return ""; + } + + StringBuilder sb = new StringBuilder(); + sb.append("{"); + + final String value = image.getValue(); + if (value != null) { + sb.append(value).append(", "); + } + + final ImageType imageType = image.getImageType(); + if (imageType != null) { + sb.append(imageType.name()); + } + + sb.append("}"); + return sb.toString(); + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/ChoiceEditActivity.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/ChoiceEditActivity.java new file mode 100644 index 000000000..b4055cf53 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/ChoiceEditActivity.java @@ -0,0 +1,225 @@ +package com.ford.syncV4.android.activity; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.View.OnClickListener; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.CheckBox; +import android.widget.EditText; +import android.widget.Spinner; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.utils.StringUtils; +import com.ford.syncV4.android.constants.Const; +import com.ford.syncV4.proxy.rpc.Choice; +import com.ford.syncV4.proxy.rpc.Image; +import com.ford.syncV4.proxy.rpc.enums.ImageType; + +import java.util.Arrays; +import java.util.Vector; + +public class ChoiceEditActivity extends Activity { + private final static String LOG_TAG = + ChoiceEditActivity.class.getSimpleName(); + // + private Choice choice = null; + // + private CheckBox useChoiceID; + private EditText choiceID; + private CheckBox useMenuName; + private EditText menuName; + private CheckBox useVRCommands; + private EditText vrCommands; + private CheckBox useImage; + private EditText image; + private Spinner imageType; + private CheckBox useSecondaryText; + private EditText secondaryText; + private CheckBox useTertiaryText; + private EditText tertiaryText; + private CheckBox useSecondaryImage; + private EditText secondaryImage; + private Spinner secondaryImageType; + // + private ArrayAdapter<ImageType> imageTypeAdapter; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.choice); + + setupUI(); + + choice = (Choice) IntentHelper.getObjectForKey( + Const.INTENTHELPER_KEY_OBJECT); + + fillUI(choice); + } + + private void fillUI(Choice choice) { + assert choice != null; + + final Integer choiceIDValue = choice.getChoiceID(); + useChoiceID.setChecked(choiceIDValue != null); + if (choiceIDValue != null) { + choiceID.setText(String.valueOf(choiceIDValue)); + } + + final String menuNameValue = choice.getMenuName(); + useMenuName.setChecked(menuNameValue != null); + if (menuNameValue != null) { + menuName.setText(menuNameValue); + } + + final Vector<String> vrCommandsValue = choice.getVrCommands(); + useVRCommands.setChecked(vrCommandsValue != null); + if (vrCommandsValue != null) { + vrCommands.setText(StringUtils.joinStrings(vrCommandsValue)); + } + + final Image imageValue = choice.getImage(); + useImage.setChecked(imageValue != null); + if (imageValue != null) { + final String imageValueValue = imageValue.getValue(); + if (imageValueValue != null) { + image.setText(imageValueValue); + } + + final ImageType imageValueType = imageValue.getImageType(); + if (imageValueType != null) { + imageType.setSelection( + imageTypeAdapter.getPosition(imageValueType)); + } + } + + final String secondaryTextValue = choice.getSecondaryText(); + useSecondaryText.setChecked(secondaryTextValue != null); + if (secondaryTextValue != null) { + secondaryText.setText(secondaryTextValue); + } + + final String tertiaryTextValue = choice.getTertiaryText(); + useTertiaryText.setChecked(tertiaryTextValue != null); + if (tertiaryTextValue != null) { + tertiaryText.setText(tertiaryTextValue); + } + + final Image secondaryImageValue = choice.getSecondaryImage(); + useSecondaryImage.setChecked(secondaryImageValue != null); + if (secondaryImageValue != null) { + final String imageValueValue = secondaryImageValue.getValue(); + if (imageValueValue != null) { + secondaryImage.setText(imageValueValue); + } + + final ImageType imageValueType = secondaryImageValue.getImageType(); + if (imageValueType != null) { + secondaryImageType.setSelection( + imageTypeAdapter.getPosition(imageValueType)); + } + } + } + + private void setupUI() { + useChoiceID = (CheckBox) findViewById(R.id.choice_useChoiceID); + choiceID = (EditText) findViewById(R.id.choice_choiceID); + useMenuName = (CheckBox) findViewById(R.id.choice_useMenuName); + menuName = (EditText) findViewById(R.id.choice_menuName); + useVRCommands = (CheckBox) findViewById(R.id.choice_useVRCommands); + vrCommands = (EditText) findViewById(R.id.choice_vrCommands); + useImage = (CheckBox) findViewById(R.id.choice_useImage); + image = (EditText) findViewById(R.id.choice_image); + imageType = (Spinner) findViewById(R.id.choice_imageType); + useSecondaryText = + (CheckBox) findViewById(R.id.choice_useSecondaryText); + secondaryText = (EditText) findViewById(R.id.choice_secondaryText); + useTertiaryText = (CheckBox) findViewById(R.id.choice_useTertiaryText); + tertiaryText = (EditText) findViewById(R.id.choice_tertiaryText); + useSecondaryImage = + (CheckBox) findViewById(R.id.choice_useSecondaryImage); + secondaryImage = (EditText) findViewById(R.id.choice_secondaryImage); + secondaryImageType = + (Spinner) findViewById(R.id.choice_secondaryImageType); + + Button btnOk = ((Button) findViewById(R.id.choice_ok)); + btnOk.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + Choice result = new Choice(); + fillChoiceFromUI(result); + + IntentHelper.addObjectForKey(result, + Const.INTENTHELPER_KEY_OBJECT); + setResult(RESULT_OK); + finish(); + } + }); + + Button btnCancel = ((Button) findViewById(R.id.choice_cancel)); + btnCancel.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + setResult(RESULT_CANCELED); + finish(); + } + }); + + imageTypeAdapter = new ArrayAdapter<ImageType>(this, + android.R.layout.simple_spinner_item, ImageType.values()); + imageTypeAdapter.setDropDownViewResource( + android.R.layout.simple_spinner_dropdown_item); + + imageType.setAdapter(imageTypeAdapter); + secondaryImageType.setAdapter(imageTypeAdapter); + } + + private void fillChoiceFromUI(Choice result) { + assert result != null; + + if (useChoiceID.isChecked()) { + try { + result.setChoiceID( + Integer.parseInt(choiceID.getText().toString())); + } catch (NumberFormatException e) { + result.setChoiceID(4242); + } + } + + if (useMenuName.isChecked()) { + result.setMenuName(menuName.getText().toString()); + } + + if (useVRCommands.isChecked()) { + result.setVrCommands(new Vector<String>(Arrays.asList( + vrCommands.getText() + .toString() + .split(StringUtils.DEFAULT_JOIN_STRING)))); + } + + if (useImage.isChecked()) { + Image imageValue = new Image(); + imageValue.setValue(image.getText().toString()); + imageValue.setImageType(imageTypeAdapter.getItem( + imageType.getSelectedItemPosition())); + result.setImage(imageValue); + } + + if (useSecondaryText.isChecked()) { + result.setSecondaryText(secondaryText.getText().toString()); + } + + if (useTertiaryText.isChecked()) { + result.setTertiaryText(tertiaryText.getText().toString()); + } + + if (useSecondaryImage.isChecked()) { + Image imageValue = new Image(); + imageValue.setValue(secondaryImage.getText().toString()); + imageValue.setImageType(imageTypeAdapter.getItem( + secondaryImageType.getSelectedItemPosition())); + result.setSecondaryImage(imageValue); + } + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/ChoiceListActivity.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/ChoiceListActivity.java new file mode 100644 index 000000000..ce059ee0a --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/ChoiceListActivity.java @@ -0,0 +1,46 @@ +package com.ford.syncV4.android.activity; + +import android.app.Activity; + +import com.ford.syncV4.proxy.rpc.Choice; +import com.ford.syncV4.proxy.rpc.Image; +import com.ford.syncV4.proxy.rpc.enums.ImageType; + +import java.util.Vector; + +/** + * Created by enikolsky on 2013-11-25. + */ +public class ChoiceListActivity extends RPCStructListActivity<Choice> { + @Override + protected Class<? extends Activity> getObjectEditActivityClass() { + return ChoiceEditActivity.class; + } + + @Override + protected RPCStructAdapter<Choice> getAdapter(Vector<Choice> objects, + int maxObjectsNumber) { + return new ChoiceAdapter(this, objects, maxObjectsNumber); + } + + @Override + protected Choice createNewObject() { + Choice choice = new Choice(); + + choice.setChoiceID(SyncProxyTester.getNewChoiceId()); + choice.setMenuName("The Show"); + choice.setSecondaryText("Must"); + choice.setTertiaryText("Go On"); + Vector<String> vrCommands = new Vector<String>(); + vrCommands.add("something"); + vrCommands.add("else"); + choice.setVrCommands(vrCommands); + + Image image = new Image(); + image.setImageType(ImageType.DYNAMIC); + image.setValue("action.png"); + choice.setImage(image); + + return choice; + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/HashIdSetUpDialog.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/HashIdSetUpDialog.java new file mode 100644 index 000000000..2ae1d77a0 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/HashIdSetUpDialog.java @@ -0,0 +1,166 @@ +package com.ford.syncV4.android.activity; + +import android.app.AlertDialog; +import android.app.Dialog; +import android.app.DialogFragment; +import android.content.Context; +import android.content.DialogInterface; +import android.os.Bundle; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.AdapterView; +import android.widget.ArrayAdapter; +import android.widget.CheckBox; +import android.widget.CompoundButton; +import android.widget.EditText; +import android.widget.Spinner; +import android.widget.TextView; + +import com.ford.syncV4.android.MainApp; +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.manager.AppPreferencesManager; +import com.ford.syncV4.android.manager.LastUsedHashIdsManager; + +import java.util.LinkedHashSet; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 2/26/14 + * Time: 4:46 PM + */ +public class HashIdSetUpDialog extends DialogFragment { + + private static final String LOG_TAG = "HashIdSetUpDialog"; + + public static HashIdSetUpDialog newInstance() { + HashIdSetUpDialog hashIdSetUpDialog = new HashIdSetUpDialog(); + return hashIdSetUpDialog; + } + + @Override + public Dialog onCreateDialog(Bundle savedInstanceState) { + final Context mContext = getActivity(); + LayoutInflater inflater = (LayoutInflater) mContext.getSystemService( + Context.LAYOUT_INFLATER_SERVICE); + final View layout = inflater.inflate(R.layout.hash_id_setup_dialog_layout, + (ViewGroup) getActivity().findViewById(R.id.itemRoot)); + + LastUsedHashIdsManager lastUsedHashIdsManager = MainApp.getInstance().getLastUsedHashIdsManager(); + // Array of choices + final String lastIds[] = lastUsedHashIdsManager.getDataForAdapter(); + + final Spinner lastHashIdsView = (Spinner) layout.findViewById(R.id.hash_id_set_up_ids_spinner_view); + ArrayAdapter<String> spinnerArrayAdapter = new ArrayAdapter<String>(getActivity(), + android.R.layout.simple_spinner_item, lastIds); + // The drop down view + spinnerArrayAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + // Apply the adapter to the spinner + lastHashIdsView.setAdapter(spinnerArrayAdapter); + final boolean[] adapterInitWorkaround = {false}; + lastHashIdsView.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() { + @Override + public void onItemSelected(AdapterView<?> parent, View view, int position, long id) { + if (adapterInitWorkaround[0]) { + setSelectedHashId(layout, lastIds[position]); + } + adapterInitWorkaround[0] = true; + } + + @Override + public void onNothingSelected(AdapterView<?> parent) { + + } + }); + + final CheckBox useHashIdView = (CheckBox) layout.findViewById(R.id.hash_id_set_up_use_hash_id_view); + useHashIdView.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { + processUseHashIdCheckBoxEvent(layout, isChecked); + } + }); + useHashIdView.setChecked(AppPreferencesManager.getUseHashId()); + processUseHashIdCheckBoxEvent(layout, AppPreferencesManager.getUseHashId()); + + final CheckBox useCustomHashIdView = (CheckBox) layout.findViewById( + R.id.hash_id_set_up_use_custom_hash_id_view); + useCustomHashIdView.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { + processUseCustomHashIdCheckBoxEvent(layout, isChecked); + } + }); + useCustomHashIdView.setChecked(AppPreferencesManager.getUseCustomHashId()); + processUseCustomHashIdCheckBoxEvent(layout, AppPreferencesManager.getUseHashId() && + AppPreferencesManager.getUseCustomHashId()); + + final EditText customHashIdView = (EditText) layout.findViewById(R.id.hash_id_set_up_custom_id_view); + Log.d(LOG_TAG, "GetHashId, hashId:" + AppPreferencesManager.getCustomHashId()); + customHashIdView.setText(AppPreferencesManager.getCustomHashId()); + + return new AlertDialog.Builder(mContext) + .setCancelable(false) + .setTitle("HashId set up") + .setPositiveButton("OK", new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, int which) { + final EditText customHashIdView = (EditText) layout.findViewById( + R.id.hash_id_set_up_custom_id_view); + Log.d(LOG_TAG, "SetSelectedHashId on click, hashId:" + + customHashIdView.getText().toString().trim()); + AppPreferencesManager.setCustomHashId( + customHashIdView.getText().toString().trim()); + } + }) + .setView(layout).show(); + } + + private void processUseHashIdCheckBoxEvent(View layout, boolean isChecked) { + Log.d(LOG_TAG, "ProcessUseHashIdCheckBoxEvent, checked:" + isChecked); + + final TextView customHashIdLabelView = (TextView) layout.findViewById(R.id.hash_id_set_up_custom_id_label_view); + final TextView lastHashIdsLabelView = (TextView) layout.findViewById(R.id.hash_id_set_up_last_ids_label_view); + final EditText customHashIdView = (EditText) layout.findViewById(R.id.hash_id_set_up_custom_id_view); + final Spinner lastHashIdsView = (Spinner) layout.findViewById(R.id.hash_id_set_up_ids_spinner_view); + final CheckBox useCustomHashIdView = (CheckBox) layout.findViewById(R.id.hash_id_set_up_use_custom_hash_id_view); + + customHashIdLabelView.setEnabled(isChecked); + lastHashIdsLabelView.setEnabled(isChecked); + customHashIdView.setEnabled(isChecked); + lastHashIdsView.setEnabled(isChecked); + useCustomHashIdView.setEnabled(isChecked); + + AppPreferencesManager.setUseHashId(isChecked); + + if (isChecked) { + processUseCustomHashIdCheckBoxEvent(layout, AppPreferencesManager.getUseCustomHashId()); + } + } + + private void processUseCustomHashIdCheckBoxEvent(View layout, boolean isChecked) { + Log.d(LOG_TAG, "ProcessUseCustomHashIdCheckBoxEvent, checked:" + isChecked); + + final TextView customHashIdLabelView = (TextView) layout.findViewById(R.id.hash_id_set_up_custom_id_label_view); + final TextView lastHashIdsLabelView = (TextView) layout.findViewById(R.id.hash_id_set_up_last_ids_label_view); + final EditText customHashIdView = (EditText) layout.findViewById(R.id.hash_id_set_up_custom_id_view); + final Spinner lastHashIdsView = (Spinner) layout.findViewById(R.id.hash_id_set_up_ids_spinner_view); + + customHashIdLabelView.setEnabled(isChecked); + lastHashIdsLabelView.setEnabled(isChecked); + customHashIdView.setEnabled(isChecked); + lastHashIdsView.setEnabled(isChecked); + + AppPreferencesManager.setUseCustomHashId(isChecked); + } + + private void setSelectedHashId(View layout, String hashId) { + final EditText customHashIdView = (EditText) layout.findViewById(R.id.hash_id_set_up_custom_id_view); + customHashIdView.setText(hashId); + + Log.d(LOG_TAG, "SetSelectedHashId, hashId:" + hashId); + AppPreferencesManager.setCustomHashId(hashId); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/IntentHelper.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/IntentHelper.java new file mode 100644 index 000000000..81110f24f --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/IntentHelper.java @@ -0,0 +1,46 @@ +package com.ford.syncV4.android.activity; + +import java.util.Hashtable; +import java.util.Map; + +/** + * Used to pass custom objects (not implementing Serializable/Parcelable + * interfaces) between activities within one application. + * + * http://stackoverflow.com/questions/2736389/how-to-pass-object-from-one-activity-to-another-in-android/11120538#11120538 + * + * @author enikolsky + * + */ +public class IntentHelper { + + private static IntentHelper sInstance; + private Map<String, Object> mMap; + + private IntentHelper() { + mMap = new Hashtable<String, Object>(); + } + + private static IntentHelper getInstance() { + if (sInstance == null) { + sInstance = new IntentHelper(); + } + return sInstance; + } + + public static void addObjectForKey(Object obj, String key) { + getInstance().mMap.put(key, obj); + } + + public static Object getObjectForKey(String key) { + return getInstance().mMap.get(key); + } + + public static boolean containsKey(String key) { + return getInstance().mMap.containsKey(key); + } + + public static void removeObjectForKey(String key) { + getInstance().mMap.remove(key); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/KeyboardPropertiesActivity.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/KeyboardPropertiesActivity.java new file mode 100644 index 000000000..0ca48db9e --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/KeyboardPropertiesActivity.java @@ -0,0 +1,197 @@ +package com.ford.syncV4.android.activity; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.CheckBox; +import android.widget.EditText; +import android.widget.Spinner; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.utils.StringUtils; +import com.ford.syncV4.android.constants.Const; +import com.ford.syncV4.proxy.rpc.KeyboardProperties; +import com.ford.syncV4.proxy.rpc.enums.KeyboardLayout; +import com.ford.syncV4.proxy.rpc.enums.KeypressMode; +import com.ford.syncV4.proxy.rpc.enums.Language; + +import java.util.Arrays; +import java.util.Vector; + +public class KeyboardPropertiesActivity extends Activity { + // + private KeyboardProperties kbdProp; + // + private CheckBox languageCheck; + private Spinner languageSpinner; + private CheckBox kbdLayoutCheck; + private Spinner kbdLayoutSpinner; + private CheckBox keypressModeCheck; + private Spinner keypressModeSpinner; + //private CheckBox sendDEntryCheck; + //private CheckBox sendDEntry; + private CheckBox charListCheck; + private EditText charList; + private CheckBox autocompleteTextCheck; + private EditText autocompleteText; + // + private ArrayAdapter<Language> languageAdapter; + private ArrayAdapter<KeyboardLayout> kbdLayoutAdapter; + private ArrayAdapter<KeypressMode> keypressModeAdapter; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_keyboardproperties); + + setupUI(); + + languageAdapter = new ArrayAdapter<Language>(this, android.R.layout.simple_spinner_item, + Language.values()); + languageAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + languageSpinner.setAdapter(languageAdapter); + + kbdLayoutAdapter = new ArrayAdapter<KeyboardLayout>(this, + android.R.layout.simple_spinner_item, KeyboardLayout.values()); + kbdLayoutAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + kbdLayoutSpinner.setAdapter(kbdLayoutAdapter); + + keypressModeAdapter = new ArrayAdapter<KeypressMode>(this, + android.R.layout.simple_spinner_item, KeypressMode.values()); + keypressModeAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + keypressModeSpinner.setAdapter(keypressModeAdapter); + + kbdProp = (KeyboardProperties) IntentHelper + .getObjectForKey(Const.INTENTHELPER_KEY_KEYBOARDPROPERTIES); + if (kbdProp == null) { + kbdProp = new KeyboardProperties(); + } + + fillUI(kbdProp); + } + + private void fillUI(KeyboardProperties kbdProperties) { + assert kbdProperties != null; + + Language language = kbdProperties.getLanguage(); + languageCheck.setChecked(language != null); + if (language != null) { + languageSpinner.setSelection(languageAdapter.getPosition(language)); + } + + KeyboardLayout kbdLayout = kbdProperties.getKeyboardLayout(); + kbdLayoutCheck.setChecked(kbdLayout != null); + if (kbdLayout != null) { + kbdLayoutSpinner.setSelection(kbdLayoutAdapter.getPosition(kbdLayout)); + } + + KeypressMode keypressMode = kbdProperties.getKeypressMode(); + keypressModeCheck.setChecked(keypressMode != null); + if (keypressMode != null) { + keypressModeSpinner.setSelection(keypressModeAdapter.getPosition(keypressMode)); + } + + Vector<String> charListValue = kbdProperties.getLimitedCharacterList(); + charListCheck.setChecked(charListValue != null); + if (charListValue != null) { + charList.setText(StringUtils.joinStrings(charListValue)); + } + + String autocompleteTextValue = kbdProperties.getAutoCompleteText(); + autocompleteTextCheck.setChecked(autocompleteTextValue != null); + if (autocompleteTextValue != null) { + autocompleteText.setText(autocompleteTextValue); + } + } + + private void setupUI() { + languageCheck = (CheckBox) findViewById(R.id.keyboardproperties_useLanguage); + languageSpinner = (Spinner) findViewById(R.id.keyboardproperties_language); + kbdLayoutCheck = (CheckBox) findViewById(R.id.keyboardproperties_useKbdLayout); + kbdLayoutSpinner = (Spinner) findViewById(R.id.keyboardproperties_kbdLayout); + keypressModeCheck = (CheckBox) findViewById(R.id.keyboardproperties_useKeypressMode); + keypressModeSpinner = (Spinner) findViewById(R.id.keyboardproperties_keypressMode); + charListCheck = (CheckBox) findViewById(R.id.keyboardproperties_useLimitedCharacterList); + charList = (EditText) findViewById(R.id.keyboardproperties_limitedCharacterList); + autocompleteTextCheck = (CheckBox) findViewById( + R.id.keyboardproperties_useAutoCompleteText); + autocompleteText = (EditText) findViewById(R.id.keyboardproperties_autoCompleteText); + + Button btnOk = ((Button) findViewById(R.id.keyboardproperties_ok)); + btnOk.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + String key = Const.INTENTHELPER_KEY_KEYBOARDPROPERTIES; + KeyboardProperties keyboardProperties = getKbdProperties(); + if (keyboardProperties == null) { + keyboardProperties = new KeyboardProperties(); + key = Const.INTENTHELPER_KEY_KEYBOARDPROPERTIES_EMPTY; + } + IntentHelper.addObjectForKey(keyboardProperties, key); + setResult(RESULT_OK); + finish(); + } + }); + + Button btnCancel = ((Button) findViewById(R.id.keyboardproperties_cancel)); + btnCancel.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + setResult(RESULT_CANCELED); + finish(); + } + }); + } + + /** + * @return {@link com.ford.syncV4.proxy.rpc.KeyboardProperties} object filled with selected + * values, or <b>null</b> if none of the properties selected + */ + private KeyboardProperties getKbdProperties() { + + boolean isLanguageCheck = languageCheck.isChecked(); + boolean isKbdLayoutCheck = kbdLayoutCheck.isChecked(); + boolean isKeyPressModeCheck = keypressModeCheck.isChecked(); + boolean isCharListCheck = charListCheck.isChecked(); + boolean isAutoCompleteTextCheck = autocompleteTextCheck.isChecked(); + + if (!isLanguageCheck && !isKbdLayoutCheck && !isKeyPressModeCheck && !isCharListCheck && + !isAutoCompleteTextCheck) { + return null; + } + + KeyboardProperties keyboardProperties = new KeyboardProperties(); + + if (isLanguageCheck) { + Language language = languageAdapter.getItem(languageSpinner.getSelectedItemPosition()); + keyboardProperties.setLanguage(language); + } + + if (isKbdLayoutCheck) { + KeyboardLayout kbdLayout = kbdLayoutAdapter + .getItem(kbdLayoutSpinner.getSelectedItemPosition()); + keyboardProperties.setKeyboardLayout(kbdLayout); + } + + if (isKeyPressModeCheck) { + KeypressMode keypressMode = keypressModeAdapter + .getItem(keypressModeSpinner.getSelectedItemPosition()); + keyboardProperties.setKeypressMode(keypressMode); + } + + if (isCharListCheck) { + Vector<String> charListValue = new Vector<String>(Arrays.asList( + charList.getText().toString().split(StringUtils.DEFAULT_JOIN_STRING))); + keyboardProperties.setLimitedCharacterList(charListValue); + } + + if (isAutoCompleteTextCheck) { + String autocompleteTextValue = autocompleteText.getText().toString(); + keyboardProperties.setAutoCompleteText(autocompleteTextValue); + } + + return keyboardProperties; + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/MultiSpinner.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/MultiSpinner.java new file mode 100644 index 000000000..19831cf26 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/MultiSpinner.java @@ -0,0 +1,137 @@ +package com.ford.syncV4.android.activity; + +import android.app.AlertDialog; +import android.content.Context; +import android.content.DialogInterface; +import android.util.AttributeSet; +import android.widget.ArrayAdapter; +import android.widget.Spinner; + +import java.util.ArrayList; +import java.util.List; + +/** + * A Spinner subclass to allow to select multiple items. Based on + * http://stackoverflow.com/questions/5015686/android-spinner-with-multiple-choice/6022474#6022474 + */ +public class MultiSpinner<ItemType> extends Spinner + implements DialogInterface.OnMultiChoiceClickListener, + DialogInterface.OnCancelListener { + + private List<ItemType> items; + private boolean[] selected; + private String defaultText; + private MultiSpinnerListener listener; + + public MultiSpinner(Context context) { + super(context); + } + + public MultiSpinner(Context arg0, AttributeSet arg1) { + super(arg0, arg1); + } + + public MultiSpinner(Context arg0, AttributeSet arg1, int arg2) { + super(arg0, arg1, arg2); + } + + @Override + public void onClick(DialogInterface dialog, int which, boolean isChecked) { + if (isChecked) { + selected[which] = true; + } else { + selected[which] = false; + } + } + + @Override + public void onCancel(DialogInterface dialog) { + // refresh text on spinner + StringBuilder spinnerBuffer = new StringBuilder(); + boolean someUnselected = false; + for (int i = 0; i < items.size(); i++) { + if (selected[i]) { + spinnerBuffer.append(items.get(i)); + spinnerBuffer.append(", "); + } else { + someUnselected = true; + } + } + String spinnerText; + if (someUnselected) { + spinnerText = spinnerBuffer.toString(); + if (spinnerText.length() > 2) { + spinnerText = + spinnerText.substring(0, spinnerText.length() - 2); + } + } else { + spinnerText = defaultText; + } + ArrayAdapter<String> adapter = new ArrayAdapter<String>(getContext(), + android.R.layout.simple_spinner_item, + new String[]{ spinnerText }); + setAdapter(adapter); + if (listener != null) { + listener.onItemsSelected(selected); + } + } + + @Override + public boolean performClick() { + AlertDialog.Builder builder = new AlertDialog.Builder(getContext()); + final CharSequence[] array = new CharSequence[items.size()]; + int i = 0; + for (ItemType item : items) { + array[i] = item.toString(); + ++i; + } + builder.setMultiChoiceItems(array, selected, this); + builder.setPositiveButton(android.R.string.ok, + new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, int which) { + dialog.cancel(); + } + }); + builder.setOnCancelListener(this); + builder.show(); + + return true; + } + + public void setItems(List<ItemType> items, String allText, + MultiSpinnerListener listener) { + this.items = items; + this.defaultText = allText; + this.listener = listener; + + // all selected by default + selected = new boolean[items.size()]; + for (int i = 0; i < selected.length; i++) { + selected[i] = true; + } + + // all text on the spinner + ArrayAdapter<String> adapter = new ArrayAdapter<String>(getContext(), + android.R.layout.simple_spinner_item, new String[]{ allText }); + setAdapter(adapter); + } + + public boolean[] getSelected() { + return selected; + } + + public List<ItemType> getSelectedItems() { + final ArrayList<ItemType> res = new ArrayList<ItemType>(); + for (int i = 0; i < selected.length; ++i) { + if (selected[i]) { + res.add(items.get(i)); + } + } + return res; + } + + public interface MultiSpinnerListener { + public void onItemsSelected(boolean[] selected); + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/PolicyFilesSetUpDialog.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/PolicyFilesSetUpDialog.java new file mode 100644 index 000000000..ea17e8165 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/PolicyFilesSetUpDialog.java @@ -0,0 +1,99 @@ +package com.ford.syncV4.android.activity; + +import android.app.Activity; +import android.app.AlertDialog; +import android.app.Dialog; +import android.app.DialogFragment; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.os.Bundle; +import android.os.Environment; +import android.view.LayoutInflater; +import android.view.View; +import android.widget.Button; +import android.widget.EditText; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.constants.Const; +import com.ford.syncV4.android.manager.AppPreferencesManager; +import com.lamerman.FileDialog; +import com.lamerman.SelectionMode; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 2/13/14 + * Time: 12:14 PM + */ +public class PolicyFilesSetUpDialog extends DialogFragment { + + private EditText mSelectedPolicyUpdateFileNameView; + + public static PolicyFilesSetUpDialog newInstance() { + PolicyFilesSetUpDialog dialog = new PolicyFilesSetUpDialog(); + return dialog; + } + + @Override + public Dialog onCreateDialog(Bundle savedInstanceState) { + final Context mContext = getActivity(); + LayoutInflater inflater = (LayoutInflater) mContext.getSystemService( + Context.LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.policy_files_setup_layout, null); + + mSelectedPolicyUpdateFileNameView = + (EditText) layout.findViewById(R.id.policy_update_local_file_name); + + final Button mPolicyUpdateSelectLocalFileView = + (Button) layout.findViewById(R.id.policy_update_select_file_button); + mPolicyUpdateSelectLocalFileView.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + // show Choose File dialog + Intent intent = new Intent(mContext, FileDialog.class); + intent.putExtra(FileDialog.START_PATH, + Environment.getExternalStorageDirectory().getPath()); + intent.putExtra(FileDialog.CAN_SELECT_DIR, false); + intent.putExtra(FileDialog.SELECTION_MODE, SelectionMode.MODE_OPEN); + startActivityForResult(intent, Const.REQUEST_POLICY_UPDATE_FILE_OPEN); + } + }); + + Button sendPolicyUpdateView = (Button) layout.findViewById(R.id.send_policy_table_update_btn_view); + sendPolicyUpdateView.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + ((SyncProxyTester) getActivity()).onPolicyFilesSetUpDialogResult_SendUpdate(); + } + }); + + return new AlertDialog.Builder(mContext) + .setTitle(getString(R.string.policy_files_setup_dialog_title)) + .setPositiveButton("OK", new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialogInterface, int i) { + String mFilePath = mSelectedPolicyUpdateFileNameView.getText().toString(); + if (mFilePath == null || mFilePath.equals("")) { + return; + } + AppPreferencesManager.setPolicyTableUpdateFilePath(mFilePath); + } + }) + .setView(layout).show(); + } + + @Override + public void onActivityResult(int requestCode, int resultCode, Intent data) { + super.onActivityResult(requestCode, resultCode, data); + + if (resultCode == Activity.RESULT_OK) { + if (requestCode == Const.REQUEST_POLICY_UPDATE_FILE_OPEN) { + String fileName = data.getStringExtra(FileDialog.RESULT_PATH); + if (mSelectedPolicyUpdateFileNameView != null) { + mSelectedPolicyUpdateFileNameView.setText(fileName); + } + } + } + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/PutFileDialog.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/PutFileDialog.java new file mode 100644 index 000000000..6a8accb5e --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/PutFileDialog.java @@ -0,0 +1,181 @@ +package com.ford.syncV4.android.activity; + +import android.app.Activity; +import android.app.AlertDialog; +import android.app.Dialog; +import android.app.DialogFragment; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.CheckBox; +import android.widget.EditText; +import android.widget.Spinner; + +import com.ford.syncV4.android.MainApp; +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.constants.Const; +import com.ford.syncV4.android.utils.AppUtils; +import com.ford.syncV4.proxy.rpc.enums.FileType; +import com.lamerman.FileDialog; +import com.lamerman.SelectionMode; + +import java.io.File; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 1/30/14 + * Time: 2:16 PM + */ +public class PutFileDialog extends DialogFragment { + + public interface PutFileDialogListener { + public void onPutFileSelected(String fileName); + } + + private static final String LOG_TAG = "PutFileDialog"; + private static final String CORRELATION_ID_KEY = "CorrelationId"; + private static final int PUTFILE_MAXFILESIZE = 4 * 1024 * 1024; // 4MB + private EditText mSelectedFileNameView; + + public static PutFileDialog newInstance(int commandCorrelationId) { + PutFileDialog putFileDialog = new PutFileDialog(); + Bundle bundle = new Bundle(); + bundle.putInt(CORRELATION_ID_KEY, commandCorrelationId); + putFileDialog.setArguments(bundle); + return putFileDialog; + } + + // Use this instance of the interface to deliver action events + PutFileDialogListener mListener; + + // Override the Fragment.onAttach() method to instantiate the NoticeDialogListener + @Override + public void onAttach(Activity activity) { + super.onAttach(activity); + // Verify that the host activity implements the callback interface + try { + // Instantiate the NoticeDialogListener so we can send events to the host + mListener = (PutFileDialogListener) activity; + } catch (ClassCastException e) { + // The activity doesn't implement the interface, throw exception + throw new ClassCastException(activity.toString() + " must implement NoticeDialogListener"); + } + } + + @Override + public Dialog onCreateDialog(Bundle savedInstanceState) { + final Context mContext = getActivity(); + LayoutInflater inflater = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.putfile, null); + + // Just for the tests we assume that getArguments have CORRELATION_ID_KEY + final int mCorrelationid = getArguments().getInt(CORRELATION_ID_KEY); + + final Button btnSelectLocalFile = (Button) layout.findViewById(R.id.putfile_selectFileButton); + btnSelectLocalFile.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + // show Choose File dialog + Intent intent = new Intent(mContext, FileDialog.class); + intent.putExtra(FileDialog.START_PATH, "/sdcard"); + intent.putExtra(FileDialog.CAN_SELECT_DIR, false); + intent.putExtra(FileDialog.SELECTION_MODE, SelectionMode.MODE_OPEN); + startActivityForResult(intent, Const.REQUEST_FILE_OPEN); + } + }); + + final EditText txtSyncFileName = (EditText) layout.findViewById(R.id.syncFileName); + + final Spinner spnFileType = (Spinner) layout.findViewById(R.id.spnFileType); + ArrayAdapter<FileType> spinnerAdapter = new ArrayAdapter<FileType>(mContext, + android.R.layout.simple_spinner_item, FileType.values()); + spinnerAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + spnFileType.setAdapter(spinnerAdapter); + + final CheckBox chkPersistentFile = (CheckBox) layout.findViewById(R.id.chkPersistentFile); + final CheckBox chkSystemFile = (CheckBox) layout.findViewById(R.id.putfile_chkSystemFile); + mSelectedFileNameView = (EditText) layout.findViewById(R.id.putfile_localFileName); + + final CheckBox chkOffset = (CheckBox) layout.findViewById(R.id.putfile_useOffset); + final EditText txtOffset = (EditText) layout.findViewById(R.id.putfile_offset); + final CheckBox chkLength = (CheckBox) layout.findViewById(R.id.putfile_useLength); + final EditText txtLength = (EditText) layout.findViewById(R.id.putfile_length); + + // Use the Builder class for convenient dialog construction + AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); + builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + String filename = mSelectedFileNameView.getText().toString(); + long fileSize = new File(filename).length(); + if (fileSize <= PUTFILE_MAXFILESIZE) { + byte[] data = AppUtils.contentsOfResource(filename); + if (data != null) { + String syncFileName = txtSyncFileName.getText().toString(); + + mListener.onPutFileSelected(syncFileName); + + if (MainApp.getInstance().getBoundProxyService() != null) { + Integer offset = null; + if (chkLength.isChecked()) { + try { + offset = Integer.valueOf(txtOffset.getText().toString()); + } catch (NumberFormatException e) { + offset = 0; + SafeToast.showToastAnyThread("Can't convert offset to integer"); + } + } + + Integer length = null; + if (chkLength.isChecked()) { + try { + length = Integer.valueOf(txtLength.getText().toString()); + } catch (NumberFormatException e) { + length = 0; + SafeToast.showToastAnyThread("Can't convert length to integer"); + } + } + + MainApp.getInstance().getBoundProxyService().commandPutFile( + (FileType) spnFileType.getSelectedItem(), syncFileName, data, + mCorrelationid, chkPersistentFile.isChecked(), + chkSystemFile.isChecked(), length, offset, null); + } + } else { + SafeToast.showToastAnyThread("Can't read data from file"); + } + } else { + SafeToast.showToastAnyThread("The size of the file exceeds the limit of " + + (PUTFILE_MAXFILESIZE / (1024 * 1024)) + " MB"); + } + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + builder.setView(layout); + return builder.create(); + } + + @Override + public void onActivityResult(int requestCode, int resultCode, Intent data) { + super.onActivityResult(requestCode, resultCode, data); + + if (resultCode == Activity.RESULT_OK) { + if (requestCode == Const.REQUEST_FILE_OPEN) { + String fileName = data.getStringExtra(FileDialog.RESULT_PATH); + if (mSelectedFileNameView != null) { + mSelectedFileNameView.setText(fileName); + } + } + } + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/RPCStructAdapter.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/RPCStructAdapter.java new file mode 100644 index 000000000..76d555a9c --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/RPCStructAdapter.java @@ -0,0 +1,115 @@ +package com.ford.syncV4.android.activity; + +import android.content.Context; +import android.util.Log; +import android.view.Gravity; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.ArrayAdapter; +import android.widget.TextView; +import android.widget.TwoLineListItem; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.proxy.RPCStruct; + +import java.util.Vector; + +/** + * Base list adapter for different RPCStruct subclasses. + * + * Created by enikolsky on 2013-11-25. + */ +abstract class RPCStructAdapter<T extends RPCStruct> extends ArrayAdapter<T> { + private static final String LOG_TAG = + RPCStructAdapter.class.getSimpleName(); + protected int maxObjectsNumber; + protected Vector<T> objects = null; + + public RPCStructAdapter(Context context, Vector<T> objects, + int maxObjectsNumber) { + super(context, 0, objects); + this.objects = objects; + this.maxObjectsNumber = maxObjectsNumber; + } + + /** + * Returns true if the objects list contains maximum number of items or + * more. + */ + protected boolean isMaxReached() { + return objects.size() >= maxObjectsNumber; + } + + @Override + public int getCount() { + // return the number of soft buttons + // + 1 to add row if maximum is not reached + return objects.size() + (isMaxReached() ? 0 : 1); + } + + @Override + public int getViewTypeCount() { + // 1 is regular soft button row + // 2 is add soft button row + return ItemType.COUNT; + } + + @Override + public int getItemViewType(int position) { + if ((position == objects.size()) && !isMaxReached()) { + return ItemType.ADD; + } + return ItemType.REGULAR; + } + + @Override + public View getView(int position, View convertView, ViewGroup parent) { + switch (getItemViewType(position)) { + case ItemType.REGULAR: { + TwoLineListItem item = (TwoLineListItem) convertView; + if (item == null) { + LayoutInflater inflater = + (LayoutInflater) getContext().getSystemService( + Context.LAYOUT_INFLATER_SERVICE); + item = (TwoLineListItem) inflater.inflate( + R.layout.rpcstruct_row, null); + } + + fillItem(item, position); + return item; + } + + case ItemType.ADD: { + TextView text = (TextView) convertView; + if (text == null) { + LayoutInflater inflater = + (LayoutInflater) getContext().getSystemService( + Context.LAYOUT_INFLATER_SERVICE); + text = (TextView) inflater.inflate( + android.R.layout.simple_list_item_1, null); + } + + text.setGravity(Gravity.CENTER); + text.setText(titleForAddRow()); + + return text; + } + + default: + Log.w(LOG_TAG, + "Unknown item view type: " + getItemViewType(position)); + return null; + } + } + + protected abstract String titleForAddRow(); + + protected abstract void fillItem(TwoLineListItem item, int position); + + protected static class ItemType { + static final int REGULAR = 0; + static final int ADD = 1; + static final int COUNT = 2; + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/RPCStructListActivity.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/RPCStructListActivity.java new file mode 100644 index 000000000..c3ba6cce6 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/RPCStructListActivity.java @@ -0,0 +1,118 @@ +package com.ford.syncV4.android.activity; + +import android.app.Activity; +import android.app.ListActivity; +import android.content.Intent; +import android.os.Bundle; +import android.util.Log; +import android.view.View; +import android.widget.Button; +import android.widget.ListView; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.constants.Const; +import com.ford.syncV4.proxy.RPCStruct; + +import java.util.Vector; + +/** + * Created by enikolsky on 2013-11-25. + */ +public abstract class RPCStructListActivity<T extends RPCStruct> + extends ListActivity { + protected static final int MAXOBJECTS_DEFAULT = 10; + private static final int REQUEST_EDIT_OBJECT = 42; + private static final String LOG_TAG = + RPCStructListActivity.class.getSimpleName(); + /** + * Index of the object being edited. + */ + protected int currentObjectIndex = -1; + protected RPCStructAdapter<T> adapter; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + setContentView(R.layout.activity_rpcstructlist); + + Button btnOk = ((Button) findViewById(R.id.rpcstructlist_ok)); + btnOk.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + IntentHelper.addObjectForKey(adapter.objects, + Const.INTENTHELPER_KEY_OBJECTSLIST); + setResult(RESULT_OK); + finish(); + } + }); + + Button btnCancel = ((Button) findViewById(R.id.rpcstructlist_cancel)); + btnCancel.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + setResult(RESULT_CANCELED); + finish(); + } + }); + + Vector<T> objects = (Vector<T>) IntentHelper.getObjectForKey( + Const.INTENTHELPER_KEY_OBJECTSLIST); + objects = (Vector<T>) objects.clone(); + int maxObjectsNumber = + getIntent().getIntExtra(Const.INTENT_KEY_OBJECTS_MAXNUMBER, + MAXOBJECTS_DEFAULT); + if (objects.size() > maxObjectsNumber) { + objects.setSize(maxObjectsNumber); + } + + adapter = getAdapter(objects, maxObjectsNumber); + setListAdapter(adapter); + } + + @Override + protected void onListItemClick(ListView l, View v, int position, long id) { + if ((position == adapter.objects.size()) && !adapter.isMaxReached()) { + adapter.objects.add(createNewObject()); + adapter.notifyDataSetChanged(); + } else { + currentObjectIndex = position; + onObjectClick(position); + } + } + + protected void onObjectClick(int position) { + T object = adapter.objects.get(position); + IntentHelper.addObjectForKey(object, Const.INTENTHELPER_KEY_OBJECT); + startActivityForResult(new Intent(this, getObjectEditActivityClass()), + REQUEST_EDIT_OBJECT); + } + + protected abstract Class<? extends Activity> getObjectEditActivityClass(); + + protected abstract RPCStructAdapter<T> getAdapter(Vector<T> objects, + int maxObjectsNumber); + + protected abstract T createNewObject(); + + @Override + protected void onActivityResult(int requestCode, int resultCode, + Intent data) { + switch (requestCode) { + case REQUEST_EDIT_OBJECT: + if (resultCode == RESULT_OK) { + T result = (T) IntentHelper.getObjectForKey( + Const.INTENTHELPER_KEY_OBJECT); + adapter.objects.set(currentObjectIndex, result); + adapter.notifyDataSetChanged(); + } + currentObjectIndex = -1; + IntentHelper.removeObjectForKey(Const.INTENTHELPER_KEY_OBJECT); + break; + + default: + Log.i(LOG_TAG, "Unknown request code: " + requestCode); + break; + } + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/RegisterAppInterfaceDialog.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/RegisterAppInterfaceDialog.java new file mode 100644 index 000000000..8956f2821 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/RegisterAppInterfaceDialog.java @@ -0,0 +1,178 @@ +package com.ford.syncV4.android.activity; + +import android.app.AlertDialog; +import android.app.Dialog; +import android.app.DialogFragment; +import android.content.Context; +import android.content.DialogInterface; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.ArrayAdapter; +import android.widget.CheckBox; +import android.widget.EditText; +import android.widget.Spinner; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.proxy.rpc.RegisterAppInterface; +import com.ford.syncV4.proxy.rpc.SyncMsgVersion; +import com.ford.syncV4.proxy.rpc.enums.AppHMIType; +import com.ford.syncV4.proxy.rpc.enums.Language; + +import java.util.Arrays; +import java.util.Vector; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 2/25/14 + * Time: 3:19 PM + */ +public class RegisterAppInterfaceDialog extends DialogFragment { + + private static final String LOG_TAG = "RegisterAppInterfaceDialog"; + + public static RegisterAppInterfaceDialog newInstance() { + RegisterAppInterfaceDialog registerAppInterfaceDialog = new RegisterAppInterfaceDialog(); + return registerAppInterfaceDialog; + } + + @Override + public Dialog onCreateDialog(Bundle savedInstanceState) { + final Context mContext = getActivity(); + LayoutInflater inflater = (LayoutInflater) mContext.getSystemService( + Context.LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.registerappinterface, + (ViewGroup) getActivity().findViewById(R.id.itemRoot)); + + final CheckBox useSyncMsgVersion = (CheckBox) layout + .findViewById(R.id.registerappinterface_useSyncMsgVersion); + final EditText syncMsgVersionMajor = (EditText) layout + .findViewById(R.id.registerappinterface_syncMsgVersionMajor); + final EditText syncMsgVersionMinor = (EditText) layout + .findViewById(R.id.registerappinterface_syncMsgVersionMinor); + final CheckBox useAppName = (CheckBox) layout + .findViewById(R.id.registerappinterface_useAppName); + final EditText appName = (EditText) layout.findViewById(R.id.registerappinterface_appName); + final CheckBox useTTSName = (CheckBox) layout + .findViewById(R.id.registerappinterface_useTTSName); + final EditText ttsName = (EditText) layout.findViewById(R.id.registerappinterface_ttsName); + final CheckBox useNgnAppName = (CheckBox) layout + .findViewById(R.id.registerappinterface_useNgnAppName); + final EditText ngnAppName = (EditText) layout + .findViewById(R.id.registerappinterface_ngnAppName); + final CheckBox useVRSynonyms = (CheckBox) layout + .findViewById(R.id.registerappinterface_useVRSynonyms); + final EditText vrSynonyms = (EditText) layout + .findViewById(R.id.registerappinterface_vrSynonyms); + + final CheckBox isMediaApp = (CheckBox) layout + .findViewById(R.id.registerappinterface_isMediaApp); + final CheckBox useDesiredLang = (CheckBox) layout + .findViewById(R.id.registerappinterface_useDesiredLang); + final Spinner desiredLangSpinner = (Spinner) layout + .findViewById(R.id.registerappinterface_desiredLangSpinner); + final CheckBox useHMIDesiredLang = (CheckBox) layout + .findViewById(R.id.registerappinterface_useHMIDesiredLang); + final Spinner hmiDesiredLangSpinner = (Spinner) layout + .findViewById(R.id.registerappinterface_hmiDesiredLangSpinner); + final CheckBox useAppHMITypes = (CheckBox) layout + .findViewById(R.id.registerappinterface_useAppHMITypes); + final MultiSpinner<AppHMIType> appHMITypeSpinner = (MultiSpinner) layout + .findViewById(R.id.registerappinterface_appHMITypeSpinner); + final CheckBox useAppID = (CheckBox) layout + .findViewById(R.id.registerappinterface_useAppID); + final EditText appID = + (EditText) layout.findViewById(R.id.registerappinterface_appID); + + final ArrayAdapter<Language> languageAdapter = + new ArrayAdapter<Language>(mContext, + android.R.layout.simple_spinner_item, + Language.values()); + languageAdapter.setDropDownViewResource( + android.R.layout.simple_spinner_dropdown_item); + // FIXME: use AppHMIType! + final ArrayAdapter<AppHMIType> appHMITypeAdapter = + new ArrayAdapter<AppHMIType>(mContext, + android.R.layout.simple_spinner_item, + AppHMIType.values()); + appHMITypeAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + + desiredLangSpinner.setAdapter(languageAdapter); + hmiDesiredLangSpinner.setAdapter(languageAdapter); + appHMITypeSpinner.setItems(Arrays.asList(AppHMIType.values()), "All", null); + + return new AlertDialog.Builder(mContext) + .setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + RegisterAppInterface registerAppInterface = new RegisterAppInterface(); + registerAppInterface.setCorrelationID(((SyncProxyTester) getActivity()).getCorrelationid()); + + if (useSyncMsgVersion.isChecked()) { + SyncMsgVersion version = new SyncMsgVersion(); + String versionStr = null; + + try { + versionStr = syncMsgVersionMinor.getText().toString(); + version.setMinorVersion(Integer.parseInt(versionStr)); + } catch (NumberFormatException e) { + version.setMinorVersion(2); + SafeToast.showToastAnyThread("Couldn't parse minor version " + versionStr); + } + + try { + versionStr = syncMsgVersionMajor.getText().toString(); + version.setMajorVersion(Integer.parseInt(versionStr)); + } catch (NumberFormatException e) { + version.setMajorVersion(2); + SafeToast.showToastAnyThread("Couldn't parse major version " + versionStr); + } + + registerAppInterface.setSyncMsgVersion(version); + } + + if (useAppName.isChecked()) { + registerAppInterface.setAppName(appName.getText().toString()); + } + if (useTTSName.isChecked()) { + registerAppInterface.setTtsName(((SyncProxyTester) getActivity()) + .ttsChunksFromString(ttsName.getText().toString())); + } + if (useNgnAppName.isChecked()) { + registerAppInterface.setNgnMediaScreenAppName(ngnAppName.getText().toString()); + } + if (useVRSynonyms.isChecked()) { + registerAppInterface.setVrSynonyms(new Vector<String>(Arrays.asList( + vrSynonyms.getText().toString().split(SyncProxyTester.JOIN_STRING)))); + } + registerAppInterface.setIsMediaApplication(isMediaApp.isChecked()); + if (useDesiredLang.isChecked()) { + registerAppInterface.setLanguageDesired(languageAdapter.getItem( + desiredLangSpinner.getSelectedItemPosition())); + } + if (useHMIDesiredLang.isChecked()) { + registerAppInterface.setHmiDisplayLanguageDesired(languageAdapter.getItem( + hmiDesiredLangSpinner.getSelectedItemPosition())); + } + if (useAppHMITypes.isChecked()) { + registerAppInterface.setAppType(new Vector<AppHMIType>(appHMITypeSpinner.getSelectedItems())); + } + if (useAppID.isChecked()) { + registerAppInterface.setAppID(appID.getText().toString()); + } + + ((SyncProxyTester) getActivity()) + .onRegisterAppInterfaceDialogResult(registerAppInterface); + } + }) + .setNegativeButton("Cancel", + new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }) + .setView(layout) + .show(); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SafeToast.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SafeToast.java new file mode 100644 index 000000000..883d2a825 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SafeToast.java @@ -0,0 +1,44 @@ +package com.ford.syncV4.android.activity; + +import android.content.Context; +import android.util.Log; +import android.widget.Toast; + +import com.ford.syncV4.android.MainApp; +import com.ford.syncV4.android.utils.AppUtils; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 1/30/14 + * Time: 2:11 PM + */ +public class SafeToast { + + public static void showToastAnyThread(CharSequence text) { + showToastAnyThread(MainApp.getInstance(), text); + } + + public static void showToastAnyThread(final Context context, final CharSequence text) { + if (AppUtils.isRunningUIThread()) { + // we are already in UI thread, it's safe to show Toast + showToastUIThread(context, text); + } else { + // we are NOT in UI thread, so scheduling task in handler + MainApp.getInstance().runInUIThread(new Runnable() { + @Override + public void run() { + showToastUIThread(context, text); + } + }); + } + } + + private static void showToastUIThread(Context context, CharSequence text) { + if (context == null) { + context = MainApp.getInstance(); + } + Log.d("SafeToast", "- Show toast: " + text); + Toast.makeText(context, text, Toast.LENGTH_LONG).show(); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SetGlobalPropertiesDialog.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SetGlobalPropertiesDialog.java new file mode 100644 index 000000000..61029a49f --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SetGlobalPropertiesDialog.java @@ -0,0 +1,254 @@ +package com.ford.syncV4.android.activity; + +import android.app.Activity; +import android.app.AlertDialog; +import android.app.Dialog; +import android.app.DialogFragment; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.os.Bundle; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.CheckBox; +import android.widget.EditText; +import android.widget.Spinner; +import android.widget.Toast; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.constants.Const; +import com.ford.syncV4.proxy.RPCRequestFactory; +import com.ford.syncV4.proxy.TTSChunkFactory; +import com.ford.syncV4.proxy.rpc.Image; +import com.ford.syncV4.proxy.rpc.KeyboardProperties; +import com.ford.syncV4.proxy.rpc.SetGlobalProperties; +import com.ford.syncV4.proxy.rpc.TTSChunk; +import com.ford.syncV4.proxy.rpc.VrHelpItem; +import com.ford.syncV4.proxy.rpc.enums.ImageType; +import com.ford.syncV4.proxy.rpc.enums.KeyboardLayout; +import com.ford.syncV4.proxy.rpc.enums.KeypressMode; +import com.ford.syncV4.proxy.rpc.enums.Language; +import com.ford.syncV4.proxy.rpc.enums.SpeechCapabilities; + +import java.util.Vector; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 2/24/14 + * Time: 11:44 AM + */ +public class SetGlobalPropertiesDialog extends DialogFragment { + + private static final String LOG_TAG = "setGlobalPropertiesDialogDialog"; + + /** + * KeyboardProperties object passed between KeyboardPropertiesActivity and + * this activity. + */ + private KeyboardProperties mCurrentKbdProperties; + + public static SetGlobalPropertiesDialog newInstance() { + SetGlobalPropertiesDialog setGlobalPropertiesDialog = new SetGlobalPropertiesDialog(); + return setGlobalPropertiesDialog; + } + + @Override + public Dialog onCreateDialog(Bundle savedInstanceState) { + final Context mContext = getActivity(); + LayoutInflater inflater = (LayoutInflater) mContext.getSystemService( + Context.LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.setglobalproperties, + (ViewGroup) getActivity().findViewById(R.id.itemRoot)); + + final EditText helpPrompt = (EditText) layout.findViewById(R.id.setglobalproperties_helpPrompt); + final EditText timeoutPrompt = (EditText) layout.findViewById(R.id.setglobalproperties_timeoutPrompt); + final EditText vrHelpTitle = (EditText) layout.findViewById(R.id.setglobalproperties_vrHelpTitle); + final EditText vrHelpItemText = (EditText) layout.findViewById(R.id.setglobalproperties_vrHelpItemText); + final CheckBox useVRHelpItemImage = (CheckBox) layout.findViewById(R.id.setglobalproperties_useVRHelpItemImage); + final EditText vrHelpItemImage = (EditText) layout.findViewById(R.id.setglobalproperties_vrHelpItemImage); + final EditText vrHelpItemPos = (EditText) layout.findViewById(R.id.setglobalproperties_vrHelpItemPos); + final CheckBox choiceHelpPrompt = (CheckBox) layout.findViewById(R.id.setglobalproperties_choiceHelpPrompt); + final CheckBox choiceTimeoutPrompt = (CheckBox) layout.findViewById(R.id.setglobalproperties_choiceTimeoutPrompt); + final CheckBox choiceVRHelpTitle = (CheckBox) layout.findViewById(R.id.setglobalproperties_choiceVRHelpTitle); + final CheckBox choiceVRHelpItem = (CheckBox) layout.findViewById(R.id.setglobalproperties_choiceVRHelpItem); + final CheckBox choiceMenuTitle = (CheckBox) layout.findViewById(R.id.setglobalproperties_choiceMenuTitle); + final EditText menuTitle = (EditText) layout.findViewById(R.id.setglobalproperties_menuTitle); + final CheckBox choiceMenuIcon = (CheckBox) layout.findViewById(R.id.setglobalproperties_choiceMenuIcon); + final EditText menuIcon = (EditText) layout.findViewById(R.id.setglobalproperties_menuIcon); + final Spinner menuIconType = (Spinner) layout.findViewById(R.id.setglobalproperties_menuIconType); + final CheckBox chkKbdProperties = (CheckBox) layout.findViewById(R.id.setglobalproperties_choiceKbdProperties); + + final ArrayAdapter<ImageType> imageTypeArrayAdapter = + ((SyncProxyTester) getActivity()).getImageTypeAdapter(); + menuIconType.setAdapter(imageTypeArrayAdapter); + menuIconType.setSelection(imageTypeArrayAdapter.getPosition(ImageType.DYNAMIC)); + + mCurrentKbdProperties = new KeyboardProperties(); + mCurrentKbdProperties.setLanguage(Language.EN_US); + mCurrentKbdProperties.setKeyboardLayout( + KeyboardLayout.QWERTY); + mCurrentKbdProperties.setKeypressMode( + KeypressMode.SINGLE_KEYPRESS); + mCurrentKbdProperties.setAutoCompleteText(getString( + R.string.keyboardproperties_autoCompleteTextDefault)); + mCurrentKbdProperties.setLimitedCharacterList(new Vector<String>() {{ + add("a"); + add("b"); + add("c"); + }}); + + Button btnKbdProperties = (Button) layout.findViewById(R.id.setglobalproperties_kbdProperties); + btnKbdProperties.setOnClickListener( + new View.OnClickListener() { + @Override + public void onClick(View v) { + IntentHelper.addObjectForKey( + mCurrentKbdProperties, + Const.INTENTHELPER_KEY_KEYBOARDPROPERTIES); + Intent intent = new Intent(mContext, KeyboardPropertiesActivity.class); + startActivityForResult(intent, Const.REQUEST_EDIT_KBDPROPERTIES); + } + }); + + return new AlertDialog.Builder(mContext) + .setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + SetGlobalProperties setGlobalProperties = + RPCRequestFactory.buildSetGlobalProperties(); + int numberOfChoices = 0; + + if (choiceHelpPrompt.isChecked()) { + Vector<TTSChunk> help = new Vector<TTSChunk>(); + String helpString = helpPrompt.getText().toString(); + for (String ttsChunk : helpString.split(SyncProxyTester.JOIN_STRING)) { + TTSChunk chunk = TTSChunkFactory.createChunk( + SpeechCapabilities.TEXT, ttsChunk); + help.add(chunk); + } + setGlobalProperties.setHelpPrompt(help); + ++numberOfChoices; + } + + if (choiceTimeoutPrompt.isChecked()) { + Vector<TTSChunk> timeout = new Vector<TTSChunk>(); + String timeoutString = timeoutPrompt.getText().toString(); + for (String ttsChunk : timeoutString.split(SyncProxyTester.JOIN_STRING)) { + TTSChunk chunk = TTSChunkFactory.createChunk( + SpeechCapabilities.TEXT, ttsChunk); + timeout.add(chunk); + } + setGlobalProperties.setTimeoutPrompt(timeout); + ++numberOfChoices; + } + + if (choiceVRHelpTitle.isChecked()) { + setGlobalProperties.setVrHelpTitle(vrHelpTitle.getText().toString()); + ++numberOfChoices; + } + + if (choiceVRHelpItem.isChecked()) { + Vector<VrHelpItem> vrHelpItems = new Vector<VrHelpItem>(); + String[] itemTextArray = vrHelpItemText.getText().toString() + .split(SyncProxyTester.JOIN_STRING); + String[] itemPosArray = vrHelpItemPos.getText().toString() + .split(SyncProxyTester.JOIN_STRING); + String[] itemImageArray = vrHelpItemImage.getText().toString() + .split(SyncProxyTester.JOIN_STRING); + int itemsCount = Math.min(itemTextArray.length, + Math.min(itemPosArray.length, itemImageArray.length)); + + for (int i = 0; i < itemsCount; ++i) { + VrHelpItem item = new VrHelpItem(); + item.setText(itemTextArray[i]); + + try { + item.setPosition(Integer.parseInt(itemPosArray[i])); + } catch (NumberFormatException e) { + // set default position + item.setPosition(1); + } + + if (useVRHelpItemImage.isChecked()) { + Image image = new Image(); + image.setValue(itemImageArray[i]); + image.setImageType(ImageType.DYNAMIC); + item.setImage(image); + } + + vrHelpItems.add(item); + } + + setGlobalProperties.setVrHelp(vrHelpItems); + ++numberOfChoices; + } + + if (choiceMenuTitle.isChecked()) { + String title = menuTitle.getText().toString(); + setGlobalProperties.setMenuTitle(title); + ++numberOfChoices; + } + + if (choiceMenuIcon.isChecked()) { + Image image = new Image(); + image.setValue(menuIcon.getText().toString()); + image.setImageType(imageTypeArrayAdapter.getItem(menuIconType.getSelectedItemPosition())); + setGlobalProperties.setMenuIcon(image); + ++numberOfChoices; + } + + if (chkKbdProperties.isChecked() && (mCurrentKbdProperties != null)) { + setGlobalProperties.setKeyboardProperties(mCurrentKbdProperties); + ++numberOfChoices; + } + + if (numberOfChoices > 0) { + setGlobalProperties.setCorrelationID(((SyncProxyTester) getActivity()) + .getCorrelationid()); + + ((SyncProxyTester) getActivity()).onSetGlobalPropertiesDialogResult(setGlobalProperties); + + mCurrentKbdProperties = null; + } else { + SafeToast.showToastAnyThread("No items selected"); + } + } + }) + .setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + mCurrentKbdProperties = null; + dialog.dismiss(); + } + }) + .setView(layout).show(); + } + + @Override + public void onActivityResult(int requestCode, int resultCode, Intent data) { + super.onActivityResult(requestCode, resultCode, data); + + if (resultCode != Activity.RESULT_OK) { + return; + } + + if (requestCode == Const.REQUEST_EDIT_KBDPROPERTIES) { + if (IntentHelper.containsKey(Const.INTENTHELPER_KEY_KEYBOARDPROPERTIES)) { + mCurrentKbdProperties = (KeyboardProperties) IntentHelper.getObjectForKey( + Const.INTENTHELPER_KEY_KEYBOARDPROPERTIES); + if (mCurrentKbdProperties == null) { + Log.w(LOG_TAG, "Returned kbdProperties is null"); + } + IntentHelper.removeObjectForKey(Const.INTENTHELPER_KEY_KEYBOARDPROPERTIES); + } else if (IntentHelper.containsKey(Const.INTENTHELPER_KEY_KEYBOARDPROPERTIES_EMPTY)) { + mCurrentKbdProperties = null; + Log.w(LOG_TAG, "Returned kbdProperties is null, probably none of the properties " + + "were selected"); + IntentHelper.removeObjectForKey(Const.INTENTHELPER_KEY_KEYBOARDPROPERTIES_EMPTY); + } + } + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SoftButtonEditActivity.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SoftButtonEditActivity.java new file mode 100644 index 000000000..1e218160f --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SoftButtonEditActivity.java @@ -0,0 +1,170 @@ +package com.ford.syncV4.android.activity; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.View.OnClickListener; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.CheckBox; +import android.widget.EditText; +import android.widget.Spinner; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.constants.Const; +import com.ford.syncV4.proxy.rpc.Image; +import com.ford.syncV4.proxy.rpc.SoftButton; +import com.ford.syncV4.proxy.rpc.enums.ImageType; +import com.ford.syncV4.proxy.rpc.enums.SoftButtonType; +import com.ford.syncV4.proxy.rpc.enums.SystemAction; + +public class SoftButtonEditActivity extends Activity { + private final static String LOG_TAG = SoftButtonEditActivity.class + .getSimpleName(); + + private SoftButton softButton = null; + + private EditText editId; + private EditText editText; + private EditText editImage; + private CheckBox checkBoxHighlighted; + private Spinner spinnerType; + private Spinner spinnerImageType; + private CheckBox checkBoxUseSystemAction; + private Spinner spinnerSystemAction; + + private ArrayAdapter<SoftButtonType> typeAdapter; + private ArrayAdapter<ImageType> imageTypeAdapter; + private ArrayAdapter<SystemAction> systemActionAdapter; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.softbutton); + + softButton = (SoftButton) IntentHelper + .getObjectForKey(Const.INTENTHELPER_KEY_OBJECT); + + editId = (EditText) findViewById(R.id.softbutton_id); + editText = (EditText) findViewById(R.id.softbutton_text); + editImage = (EditText) findViewById(R.id.softbutton_image); + checkBoxHighlighted = (CheckBox) findViewById(R.id.softbutton_isHighlighted); + spinnerType = (Spinner) findViewById(R.id.softbutton_type); + spinnerImageType = (Spinner) findViewById(R.id.softbutton_imageType); + checkBoxUseSystemAction = (CheckBox) findViewById(R.id.softbutton_useSystemAction); + spinnerSystemAction = (Spinner) findViewById(R.id.softbutton_systemAction); + + Button btnOk = ((Button) findViewById(R.id.softbutton_ok)); + btnOk.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + SoftButton result = new SoftButton(); + result.setType((SoftButtonType) spinnerType.getSelectedItem()); + switch (result.getType()) { + case SBT_TEXT: + setTextToSoftButton(result); + break; + case SBT_IMAGE: + setImageToSoftButton(result); + break; + case SBT_BOTH: + setTextToSoftButton(result); + setImageToSoftButton(result); + break; + } + result.setIsHighlighted(checkBoxHighlighted.isChecked()); + if (checkBoxUseSystemAction.isChecked()) { + result.setSystemAction((SystemAction) spinnerSystemAction + .getSelectedItem()); + } + try { + result.setSoftButtonID(Integer.parseInt(editId.getText() + .toString())); + } catch (NumberFormatException e) { + result.setSoftButtonID(5555); + } + + IntentHelper.addObjectForKey(result, + Const.INTENTHELPER_KEY_OBJECT); + setResult(RESULT_OK); + finish(); + } + }); + + Button btnCancel = ((Button) findViewById(R.id.softbutton_cancel)); + btnCancel.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + setResult(RESULT_CANCELED); + finish(); + } + }); + + editId.setText(String.valueOf(softButton.getSoftButtonID())); + + // setup adapters + typeAdapter = new ArrayAdapter<SoftButtonType>(this, + android.R.layout.simple_spinner_item, SoftButtonType.values()); + typeAdapter + .setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + spinnerType.setAdapter(typeAdapter); + + imageTypeAdapter = new ArrayAdapter<ImageType>(this, + android.R.layout.simple_spinner_item, ImageType.values()); + imageTypeAdapter + .setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + spinnerImageType.setAdapter(imageTypeAdapter); + spinnerImageType.setSelection(imageTypeAdapter.getPosition(ImageType.DYNAMIC)); + + systemActionAdapter = new ArrayAdapter<SystemAction>(this, + android.R.layout.simple_spinner_item, SystemAction.values()); + systemActionAdapter + .setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + spinnerSystemAction.setAdapter(systemActionAdapter); + + spinnerType.setSelection(typeAdapter.getPosition(softButton.getType())); + switch (softButton.getType()) { + case SBT_TEXT: + setTextFromSoftButton(); + break; + case SBT_IMAGE: + setImageFromSoftButton(); + break; + case SBT_BOTH: + setTextFromSoftButton(); + setImageFromSoftButton(); + break; + } + checkBoxHighlighted.setChecked(softButton.getIsHighlighted()); + SystemAction systemAction = softButton.getSystemAction(); + if (systemAction != null) { + spinnerSystemAction.setSelection( + systemActionAdapter.getPosition(systemAction)); + } else { + checkBoxUseSystemAction.setChecked(false); + spinnerSystemAction.setSelection(0); + } + } + + private void setImageFromSoftButton() { + editImage.setText(softButton.getImage().getValue()); + spinnerImageType.setSelection(imageTypeAdapter.getPosition(softButton + .getImage().getImageType())); + } + + private void setTextFromSoftButton() { + editText.setText(softButton.getText()); + } + + private void setTextToSoftButton(SoftButton softButton) { + softButton.setText(editText.getText().toString()); + } + + private void setImageToSoftButton(SoftButton softButton) { + Image image = new Image(); + image.setValue(editImage.getText().toString()); + image.setImageType((ImageType) spinnerImageType.getSelectedItem()); + softButton.setImage(image); + } + +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SoftButtonsAdapter.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SoftButtonsAdapter.java new file mode 100644 index 000000000..11644799b --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SoftButtonsAdapter.java @@ -0,0 +1,80 @@ +package com.ford.syncV4.android.activity; + +import android.content.Context; +import android.view.View; +import android.widget.ImageButton; +import android.widget.TextView; +import android.widget.TwoLineListItem; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.proxy.rpc.SoftButton; +import com.ford.syncV4.proxy.rpc.enums.SystemAction; + +import java.util.Vector; + +class SoftButtonsAdapter extends RPCStructAdapter<SoftButton> { + public SoftButtonsAdapter(Context context, Vector<SoftButton> objects, + int maxSoftButtonsNumber) { + super(context, objects, maxSoftButtonsNumber); + } + + @Override + protected String titleForAddRow() { + return "Add soft button"; + } + + @Override + protected void fillItem(TwoLineListItem item, int position) { + final SoftButton softButton = getItem(position); + TextView text1 = item.getText1(); + TextView text2 = item.getText2(); + + ImageButton btnDelete = + (ImageButton) item.findViewById(R.id.rpcstructrow_deleteButton); + btnDelete.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + objects.remove(softButton); + notifyDataSetChanged(); + } + }); + + StringBuilder b = new StringBuilder(); + b.append("[").append(softButton.getType().name()).append("], "); + switch (softButton.getType()) { + case SBT_TEXT: + b.append("\"").append(softButton.getText()).append("\""); + break; + case SBT_IMAGE: + b.append("\"") + .append(softButton.getImage().getValue()) + .append("\" [") + .append(softButton.getImage().getImageType().name()) + .append("]"); + break; + case SBT_BOTH: + b.append("\"") + .append(softButton.getText()) + .append("\", \"") + .append(softButton.getImage().getValue()) + .append("\" [") + .append(softButton.getImage().getImageType().name()) + .append("]"); + break; + } + + String line1 = b.toString(); + final SystemAction systemAction = softButton.getSystemAction(); + final StringBuilder line2Builder = new StringBuilder(); + if (systemAction != null) { + line2Builder.append(systemAction.name()); + line2Builder.append(", "); + } + + line2Builder.append(softButton.getIsHighlighted() ? "" : "non-"); + line2Builder.append("highlighted, id="); + line2Builder.append(softButton.getSoftButtonID()); + text1.setText(line1); + text2.setText(line2Builder.toString()); + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SoftButtonsListActivity.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SoftButtonsListActivity.java new file mode 100644 index 000000000..2a982359b --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SoftButtonsListActivity.java @@ -0,0 +1,43 @@ +package com.ford.syncV4.android.activity; + +import android.app.Activity; + +import com.ford.syncV4.proxy.rpc.Image; +import com.ford.syncV4.proxy.rpc.SoftButton; +import com.ford.syncV4.proxy.rpc.enums.ImageType; +import com.ford.syncV4.proxy.rpc.enums.SoftButtonType; +import com.ford.syncV4.proxy.rpc.enums.SystemAction; + +import java.util.Vector; + +public class SoftButtonsListActivity extends RPCStructListActivity<SoftButton> { + @Override + protected SoftButton createNewObject() { + // create and add default soft button + Image img = new Image(); + img.setValue("action.png"); + img.setImageType(ImageType.DYNAMIC); + + SoftButton sb = new SoftButton(); + sb.setSoftButtonID(SyncProxyTester.getNewSoftButtonId()); + sb.setText("Close"); + sb.setType(SoftButtonType.SBT_BOTH); + sb.setImage(img); + sb.setIsHighlighted(true); + sb.setSystemAction(SystemAction.DEFAULT_ACTION); + + return sb; + } + + @Override + protected Class<? extends Activity> getObjectEditActivityClass() { + return SoftButtonEditActivity.class; + } + + @Override + protected RPCStructAdapter<SoftButton> getAdapter( + Vector<SoftButton> objects, int maxObjectsNumber) { + return new SoftButtonsAdapter(this, objects, maxObjectsNumber); + } + +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SubscriptionsVehicleDataDialog.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SubscriptionsVehicleDataDialog.java new file mode 100644 index 000000000..dad7ad890 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SubscriptionsVehicleDataDialog.java @@ -0,0 +1,154 @@ +package com.ford.syncV4.android.activity; + +import android.app.AlertDialog; +import android.app.Dialog; +import android.app.DialogFragment; +import android.content.Context; +import android.content.DialogInterface; +import android.os.Bundle; + +import com.ford.syncV4.proxy.rpc.SubscribeVehicleData; +import com.ford.syncV4.proxy.rpc.UnsubscribeVehicleData; +import com.ford.syncV4.proxy.rpc.enums.VehicleDataType; + +import java.util.HashMap; +import java.util.Map; +import java.util.Vector; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 2/24/14 + * Time: 2:19 PM + */ +public class SubscriptionsVehicleDataDialog extends DialogFragment { + + private static final String LOG_TAG = "SubscriptionsVehicleDataDialog"; + + private static final Map<VehicleDataType, String> METHOD_NAMES_MAP = + new HashMap<VehicleDataType, String>() {{ + put(VehicleDataType.VEHICLEDATA_GPS, "Gps"); + put(VehicleDataType.VEHICLEDATA_SPEED, "Speed"); + put(VehicleDataType.VEHICLEDATA_RPM, "Rpm"); + put(VehicleDataType.VEHICLEDATA_FUELLEVEL, "FuelLevel"); + put(VehicleDataType.VEHICLEDATA_FUELLEVEL_STATE, "FuelLevel_State"); + put(VehicleDataType.VEHICLEDATA_FUELCONSUMPTION, "InstantFuelConsumption"); + put(VehicleDataType.VEHICLEDATA_EXTERNTEMP, "ExternalTemperature"); + // put(VehicleDataType.VEHICLEDATA_VIN, "VIN"); + put(VehicleDataType.VEHICLEDATA_PRNDL, "Prndl"); + put(VehicleDataType.VEHICLEDATA_TIREPRESSURE, "TirePressure"); + put(VehicleDataType.VEHICLEDATA_ODOMETER, "Odometer"); + put(VehicleDataType.VEHICLEDATA_BELTSTATUS, "BeltStatus"); + put(VehicleDataType.VEHICLEDATA_BODYINFO, "BodyInformation"); + put(VehicleDataType.VEHICLEDATA_DEVICESTATUS, "DeviceStatus"); + put(VehicleDataType.VEHICLEDATA_BRAKING, "DriverBraking"); + put(VehicleDataType.VEHICLEDATA_WIPERSTATUS, "WiperStatus"); + put(VehicleDataType.VEHICLEDATA_HEADLAMPSTATUS, "HeadLampStatus"); + put(VehicleDataType.VEHICLEDATA_BATTVOLTAGE, "BatteryVoltage"); + put(VehicleDataType.VEHICLEDATA_ENGINETORQUE, "EngineTorque"); + put(VehicleDataType.VEHICLEDATA_ACCPEDAL, "AccPedalPosition"); + put(VehicleDataType.VEHICLEDATA_STEERINGWHEEL, "SteeringWheelAngle"); + put(VehicleDataType.VEHICLEDATA_ECALLINFO, "ECallInfo"); + put(VehicleDataType.VEHICLEDATA_AIRBAGSTATUS, "AirbagStatus"); + put(VehicleDataType.VEHICLEDATA_EMERGENCYEVENT, "EmergencyEvent"); + put(VehicleDataType.VEHICLEDATA_CLUSTERMODESTATUS, "ClusterModeStatus"); + put(VehicleDataType.VEHICLEDATA_MYKEY, "MyKey"); + }}; + + public static SubscriptionsVehicleDataDialog newInstance() { + SubscriptionsVehicleDataDialog subscriptionsVehicleDataDialog = new SubscriptionsVehicleDataDialog(); + return subscriptionsVehicleDataDialog; + } + + @Override + public Dialog onCreateDialog(Bundle savedInstanceState) { + final Context mContext = getActivity(); + + // the local copy of isVehicleDataSubscribed + final boolean[] checkedVehicleDataTypes = ((SyncProxyTester) getActivity()) + .cloneIsVehicleDataSubscribed(); + + return new AlertDialog.Builder(mContext) + .setMultiChoiceItems(vehicleDataTypeNames(), checkedVehicleDataTypes, + new DialogInterface.OnMultiChoiceClickListener() { + @Override + public void onClick(DialogInterface dialog, int which, boolean isChecked) { + /** + * NB! This method is intentionally left empty. If the 3rd + * parameter to setMultiChoiceItems() is null, the user's + * changes to checked items don't save. + **/ + } + }) + .setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + Vector<VehicleDataType> subscribeVehicleData = new Vector<VehicleDataType>(); + Vector<VehicleDataType> unsubscribeVehicleData = new Vector<VehicleDataType>(); + VehicleDataType[] dataTypes = VehicleDataType.values(); + + // subscribe and unsubscribe to new checked/unchecked items only + for (int i = 0; i < checkedVehicleDataTypes.length; i++) { + boolean checked = checkedVehicleDataTypes[i]; + boolean wasChecked = ((SyncProxyTester) getActivity()) + .getIsVehicleDataSubscribedAt(i); + if (checked && !wasChecked) { + subscribeVehicleData.add(dataTypes[i]); + } else if (!checked && wasChecked) { + unsubscribeVehicleData.add(dataTypes[i]); + } + } + + if (!subscribeVehicleData.isEmpty()) { + SubscribeVehicleData msg = new SubscribeVehicleData(); + for (VehicleDataType vdt : subscribeVehicleData) { + ((SyncProxyTester) getActivity()) + .setVehicleDataParam(msg, SubscribeVehicleData.class, + "set" + METHOD_NAMES_MAP.get(vdt)); + } + msg.setCorrelationID(((SyncProxyTester) getActivity()).getCorrelationid()); + + ((SyncProxyTester) getActivity()).onSubscribeVehicleDialogResult(msg); + } + + if (!unsubscribeVehicleData.isEmpty()) { + UnsubscribeVehicleData msg = new UnsubscribeVehicleData(); + for (VehicleDataType vdt : unsubscribeVehicleData) { + ((SyncProxyTester) getActivity()). + setVehicleDataParam(msg, UnsubscribeVehicleData.class, + "set" + METHOD_NAMES_MAP.get(vdt)); + } + msg.setCorrelationID(((SyncProxyTester) getActivity()).getCorrelationid()); + + ((SyncProxyTester) getActivity()).onUnsubscribeVehicleDialogResult(msg); + } + ((SyncProxyTester) getActivity()) + .setIsVehicleDataSubscribed(checkedVehicleDataTypes.clone()); + + if (subscribeVehicleData.isEmpty() && unsubscribeVehicleData.isEmpty()) { + SafeToast.showToastAnyThread("Nothing new here"); + } + } + }) + .setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }) + .show(); + } + + private String[] vehicleDataTypeNames() { + return new String[]{ "GPS", "Speed", "RPM", + "Fuel Level", "Fuel Level State", + "Fuel Consumption", "External Temp", + "VIN", "PRNDL", "Tire Pressure", + "Odometer", "Belt Status", + "Body Info", "Device Status", + "Braking", "Wiper Status", + "Head Lamp Status", "Batt Voltage", + "Engine Torque", "Acc Pedal", + "Steering Wheel", "ECall Info", + "Airbag Status", "Emergency Event", + "Cluster Mode Status", "MyKey" }; + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SyncProxyTester.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SyncProxyTester.java new file mode 100644 index 000000000..03deff151 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/SyncProxyTester.java @@ -0,0 +1,3894 @@ +package com.ford.syncV4.android.activity; + +import android.app.AlertDialog; +import android.app.Dialog; +import android.app.DialogFragment; +import android.app.ProgressDialog; +import android.bluetooth.BluetoothAdapter; +import android.content.Context; +import android.content.DialogInterface; +import android.content.DialogInterface.OnMultiChoiceClickListener; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.SharedPreferences; +import android.content.pm.PackageManager.NameNotFoundException; +import android.media.AudioManager; +import android.media.MediaPlayer; +import android.media.MediaPlayer.OnCompletionListener; +import android.os.Bundle; +import android.os.Environment; +import android.os.Handler; +import android.os.Looper; +import android.support.v4.app.FragmentActivity; +import android.util.Log; +import android.util.Pair; +import android.view.LayoutInflater; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; +import android.widget.AdapterView; +import android.widget.AdapterView.OnItemClickListener; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.CheckBox; +import android.widget.CheckedTextView; +import android.widget.CompoundButton; +import android.widget.EditText; +import android.widget.ListView; +import android.widget.ScrollView; +import android.widget.Spinner; +import android.widget.Toast; + +import com.ford.syncV4.android.MainApp; +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.activity.mobilenav.AudioServicePreviewFragment; +import com.ford.syncV4.android.activity.mobilenav.MobileNavPreviewFragment; +import com.ford.syncV4.android.adapters.LogAdapter; +import com.ford.syncV4.android.constants.Const; +import com.ford.syncV4.android.constants.SyncSubMenu; +import com.ford.syncV4.android.listener.ConnectionListener; +import com.ford.syncV4.android.listener.ConnectionListenersManager; +import com.ford.syncV4.android.manager.AppPreferencesManager; +import com.ford.syncV4.android.manager.BluetoothDeviceManager; +import com.ford.syncV4.android.manager.IBluetoothDeviceManager; +import com.ford.syncV4.android.module.GenericRequest; +import com.ford.syncV4.android.module.ModuleTest; +import com.ford.syncV4.android.policies.PoliciesTesterActivity; +import com.ford.syncV4.android.receivers.ISyncReceiver; +import com.ford.syncV4.android.receivers.SyncReceiver; +import com.ford.syncV4.android.service.ICloseSession; +import com.ford.syncV4.android.service.IProxyServiceBinder; +import com.ford.syncV4.android.service.IProxyServiceEvent; +import com.ford.syncV4.android.service.ProxyService; +import com.ford.syncV4.android.utils.AppUtils; +import com.ford.syncV4.exception.SyncException; +import com.ford.syncV4.protocol.enums.ServiceType; +import com.ford.syncV4.proxy.RPCMessage; +import com.ford.syncV4.proxy.RPCRequest; +import com.ford.syncV4.proxy.RPCResponse; +import com.ford.syncV4.proxy.TTSChunkFactory; +import com.ford.syncV4.proxy.constants.Names; +import com.ford.syncV4.proxy.rpc.AddCommand; +import com.ford.syncV4.proxy.rpc.AddSubMenu; +import com.ford.syncV4.proxy.rpc.Alert; +import com.ford.syncV4.proxy.rpc.ChangeRegistration; +import com.ford.syncV4.proxy.rpc.Choice; +import com.ford.syncV4.proxy.rpc.DeleteCommand; +import com.ford.syncV4.proxy.rpc.DeleteFile; +import com.ford.syncV4.proxy.rpc.DeleteInteractionChoiceSet; +import com.ford.syncV4.proxy.rpc.DeleteSubMenu; +import com.ford.syncV4.proxy.rpc.DiagnosticMessage; +import com.ford.syncV4.proxy.rpc.EncodedSyncPData; +import com.ford.syncV4.proxy.rpc.EndAudioPassThru; +import com.ford.syncV4.proxy.rpc.GetDTCs; +import com.ford.syncV4.proxy.rpc.GetVehicleData; +import com.ford.syncV4.proxy.rpc.Image; +import com.ford.syncV4.proxy.rpc.OnAudioPassThru; +import com.ford.syncV4.proxy.rpc.OnKeyboardInput; +import com.ford.syncV4.proxy.rpc.OnTouchEvent; +import com.ford.syncV4.proxy.rpc.PerformAudioPassThru; +import com.ford.syncV4.proxy.rpc.PerformInteraction; +import com.ford.syncV4.proxy.rpc.ReadDID; +import com.ford.syncV4.proxy.rpc.RegisterAppInterface; +import com.ford.syncV4.proxy.rpc.ResetGlobalProperties; +import com.ford.syncV4.proxy.rpc.ScrollableMessage; +import com.ford.syncV4.proxy.rpc.SetAppIcon; +import com.ford.syncV4.proxy.rpc.SetDisplayLayout; +import com.ford.syncV4.proxy.rpc.SetGlobalProperties; +import com.ford.syncV4.proxy.rpc.SetMediaClockTimer; +import com.ford.syncV4.proxy.rpc.Show; +import com.ford.syncV4.proxy.rpc.ShowConstantTBT; +import com.ford.syncV4.proxy.rpc.Slider; +import com.ford.syncV4.proxy.rpc.SoftButton; +import com.ford.syncV4.proxy.rpc.Speak; +import com.ford.syncV4.proxy.rpc.StartTime; +import com.ford.syncV4.proxy.rpc.SubscribeVehicleData; +import com.ford.syncV4.proxy.rpc.SyncPData; +import com.ford.syncV4.proxy.rpc.TTSChunk; +import com.ford.syncV4.proxy.rpc.Turn; +import com.ford.syncV4.proxy.rpc.UnregisterAppInterface; +import com.ford.syncV4.proxy.rpc.UnsubscribeButton; +import com.ford.syncV4.proxy.rpc.UnsubscribeVehicleData; +import com.ford.syncV4.proxy.rpc.UpdateTurnList; +import com.ford.syncV4.proxy.rpc.VrHelpItem; +import com.ford.syncV4.proxy.rpc.enums.AudioType; +import com.ford.syncV4.proxy.rpc.enums.BitsPerSample; +import com.ford.syncV4.proxy.rpc.enums.ButtonName; +import com.ford.syncV4.proxy.rpc.enums.GlobalProperty; +import com.ford.syncV4.proxy.rpc.enums.ImageType; +import com.ford.syncV4.proxy.rpc.enums.InteractionMode; +import com.ford.syncV4.proxy.rpc.enums.Language; +import com.ford.syncV4.proxy.rpc.enums.LayoutMode; +import com.ford.syncV4.proxy.rpc.enums.Result; +import com.ford.syncV4.proxy.rpc.enums.SamplingRate; +import com.ford.syncV4.proxy.rpc.enums.SoftButtonType; +import com.ford.syncV4.proxy.rpc.enums.SpeechCapabilities; +import com.ford.syncV4.proxy.rpc.enums.SystemAction; +import com.ford.syncV4.proxy.rpc.enums.TextAlignment; +import com.ford.syncV4.proxy.rpc.enums.UpdateMode; +import com.ford.syncV4.proxy.rpc.enums.VehicleDataType; +import com.ford.syncV4.session.Session; +import com.ford.syncV4.util.Base64; +import com.lamerman.FileDialog; +import com.lamerman.SelectionMode; + +import java.io.BufferedOutputStream; +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.Hashtable; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Vector; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.atomic.AtomicInteger; + +public class SyncProxyTester extends FragmentActivity implements OnClickListener, + IBluetoothDeviceManager, ConnectionListener, PutFileDialog.PutFileDialogListener, + IProxyServiceEvent { + + private static final String VERSION = "$Version:$"; + private static final String LOG_TAG = "SyncProxyTester"; + private static final String ButtonSubscriptions = "ButtonSubscriptions"; + private static final String VehicleDataSubscriptions = "VehicleDataSubscriptions"; + /** + * The name of the file where all the data coming with + * {@link OnAudioPassThru} notifications is saved. The root directory is the + * external storage. + */ + private static final String AUDIOPASSTHRU_OUTPUT_FILE = "audiopassthru.wav"; + /** + * String to join/split help, timeout, VR prompts, etc. + */ + public static final String JOIN_STRING = ","; + private static final int ALERT_MAXSOFTBUTTONS = 4; + private static final int SCROLLABLEMESSAGE_MAXSOFTBUTTONS = 8; + private static final int SHOW_MAXSOFTBUTTONS = 8; + private static final int SHOWCONSTANTTBT_MAXSOFTBUTTONS = 3; + private static final int UPDATETURNLIST_MAXSOFTBUTTONS = 1; + private static final int CREATECHOICESET_MAXCHOICES = 100; + private final static int REQUEST_CHOOSE_XML_TEST = 51; + private static final int CHOICESETID_UNSET = -1; + private static final String MSC_PREFIX = "msc_"; + private static SyncProxyTester _activity; + private static ArrayList<Object> _logMessages = new ArrayList<Object>(); + private LogAdapter mLogAdapter; + private static byte[] _ESN; + /** + * Autoincrementing id for new softbuttons. + */ + private static int autoIncSoftButtonId = 5500; + /** + * Autoincrementing id for new choices. + */ + private static int autoIncChoiceId = 9000; + /** + * In onCreate() specifies if it is the first time the activity is created + * during this app launch. + */ + private static boolean isFirstActivityRun = true; + private final int PROXY_START = 5; + private final int XML_TEST = 7; + private final int POLICIES_TEST = 8; + private final int MNU_TOGGLE_CONSOLE = 9; + private final int MNU_CLEAR = 10; + private final int MNU_EXIT = 11; + private final int MNU_TOGGLE_MEDIA = 12; + private final int MNU_CLOSESESSION = 14; + private final int MNU_APP_VERSION = 15; + private final int MNU_CLEAR_FUNCTIONS_USAGE = 16; + private final int MNU_WAKELOCK = 17; + private final int MNU_SET_UP_POLICY_FILES = 18; + private final int MNU_HASH_ID_SETUP = 19; + private ModuleTest _testerMain; + private ScrollView _scroller = null; + private ListView mListview = null; + private ArrayAdapter<SyncSubMenu> mSubmenuAdapter = null; + private ArrayAdapter<Integer> mCommandAdapter = null; + private Map<Integer, Integer> mCommandIdToParentSubmenuMap = null; + private ArrayAdapter<Integer> mChoiceSetAdapter = null; + private ArrayAdapter<String> mPutFileAdapter = null; + /** + * Latest choiceSetId, required to add it to the adapter when a successful + * CreateInteractionChoiceSetResponse comes. + */ + private int mLatestCreateChoiceSetId = CHOICESETID_UNSET; + /** + * Latest choiceSetId, required to delete it from the adapter when a + * successful DeleteInteractionChoiceSetResponse comes. + */ + private int _latestDeleteChoiceSetId = CHOICESETID_UNSET; + /** + * Latest SyncSubMenu, required to delete the submenu from the adapter + * when a successful DeleteSubMenuResponse comes. + */ + private SyncSubMenu _latestDeleteSubmenu = null; + /** + * Latest SyncSubMenu, required to add the submenu from the adapter when a + * successful AddSubMenuResponse comes. + */ + private SyncSubMenu mLatestAddSubmenu = null; + private Pair<Integer, Integer> mLatestAddCommand = null; + private Integer _latestDeleteCommandCmdID = null; + private int mAutoIncCorrId = 101; + private int autoIncChoiceSetId = 1; + private int autoIncChoiceSetIdCmdId = 1; + private ArrayAdapter<ButtonName> mButtonAdapter = null; + private boolean[] isButtonSubscribed = null; + private ArrayAdapter<VehicleDataType> _vehicleDataType = null; + private boolean[] isVehicleDataSubscribed = null; + /** + * List of soft buttons for current function. Passed between + * {@link SoftButtonsListActivity} and this activity. + */ + private Vector<SoftButton> currentSoftButtons; + /** + * The Include Soft Buttons checkbox in the current dialog. Kept here to + * check it when the user has explicitly set the soft buttons. + */ + private CheckBox chkIncludeSoftButtons; + /** + * Reference to PutFile dialog's local filename text field, so that the + * filename is set after choosing. + */ + private EditText txtLocalFileName; + /** + * Stores the number of selections of each message to sort them by + * most-popular usage. + */ + private Map<String, Integer> messageSelectCount; + /** + * The output stream to write audioPassThru data. + */ + private OutputStream audioPassThruOutStream = null; + /** + * Media player for the stream of audio pass thru. + */ + private MediaPlayer audioPassThruMediaPlayer = null; + /** + * The most recent sent PerformAudioPassThru message, saved in case we need + * to retry the request. + */ + private PerformAudioPassThru latestPerformAudioPassThruMsg = null; + /** + * Shared ArrayAdapter containing ImageType values. + */ + private ArrayAdapter<ImageType> imageTypeAdapter; + // Request id for SoftButtonsListActivity + static final int REQUEST_LIST_SOFTBUTTONS = 43; + // Request id for ChoiceListActivity + static final int REQUEST_LIST_CHOICES = 45; + /** + * Time out in milliseconds for exit from application. If application is not correctly + * destroyed within specified timeout - then we force destroy procedure + */ + private static final int EXIT_TIMEOUT = 3000; + /** + * Handler object to monitor exit procedure. If exit procedure fails, then this object will + * manage application to destroy + */ + private Handler mStopProxyServiceTimeOutHandler; + /** + * Handler object to monitor stop non RPC services. If stop procedure will fail, then this object + * will start destroy service functionality + */ + private Handler mStopServicesTimeOutHandler; + /** + * Counter of the Services + */ + private AtomicInteger mServicesCounter = new AtomicInteger(); + /** + * Handler object to monitor stop proxy procedure for the Bluetooth connection. + */ + private Handler mBluetoothStopProxyServiceTimeOutHandler; + /** + * progress dialog of the Exit Application + */ + private ProgressDialog mExitProgressDialog; + /** + * UI Handler to perform actions in UI Thread + */ + private final Handler mUIHandler = new Handler(Looper.getMainLooper()); + private final static String APP_SETUP_DIALOG_TAG = "AppSetupDialogTag"; + private final static String POLICY_FILES_SETUP_DIALOG_TAG = "PolicyFilesSetupDialogTag"; + private final static String PUT_FILE_DIALOG_TAG = "PutFileDialogTag"; + private final static String ADD_COMMAND_DIALOG_TAG = "AddCommandDialogTag"; + private final static String ADD_SUB_MENU_DIALOG_TAG = "AddSubMenuDialogTag"; + private final static String SET_GLOBAL_PROPERTIES_DIALOG_TAG = "SetGlobalPropertiesDialogTag"; + private final static String SUBSCRIPTION_VEHICLE_DATA_DIALOG_TAG = "SubscriptionVehicleDataDialogTag"; + private final static String REGISTER_APP_INTERFACE_DIALOG_TAG = "RegisterAppInterfaceDialogTag"; + private final static String HASH_ID_SET_UP_DIALOG_TAG = "HashIdSetUpDialogTag"; + + private SyncReceiver mSyncReceiver; + private BluetoothDeviceManager mBluetoothDeviceManager; + private Session rpcSession = new Session(); + + // Get Bound Proxy Service from MainApp + private ProxyService mBoundProxyService; + private ExecutorService mStreamCommandsExecutorService; + + public static SyncProxyTester getInstance() { + return _activity; + } + + public static void setESN(byte[] ESN) { + _ESN = ESN; + } + + public static int getNewSoftButtonId() { + return autoIncSoftButtonId++; + } + + public static int getNewChoiceId() { + return autoIncChoiceId++; + } + + public void runInUIThread(Runnable runnable) { + mUIHandler.post(runnable); + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + Log.d(LOG_TAG, SyncProxyTester.class.getSimpleName() + " On Create"); + + _activity = this; + + AppPreferencesManager.setAppContext(this); + + setContentView(R.layout.main); + + getProxyService(); + + addListeners(); + + mStreamCommandsExecutorService = Executors.newFixedThreadPool(3); + + _scroller = (ScrollView) findViewById(R.id.scrollConsole); + + findViewById(R.id.btnSendMessage).setOnClickListener(this); + findViewById(R.id.btnPlayPause).setOnClickListener(this); + + resetAdapters(); + + _vehicleDataType = new ArrayAdapter<VehicleDataType>(this, + android.R.layout.simple_spinner_item, VehicleDataType.values()); + _vehicleDataType.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + + imageTypeAdapter = new ArrayAdapter<ImageType>(this, android.R.layout.simple_spinner_item, ImageType.values()); + imageTypeAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + + mLogAdapter = new LogAdapter(LOG_TAG, false, this, R.layout.row, _logMessages); + + mListview = (ListView) findViewById(R.id.messageList); + mListview.setClickable(true); + mListview.setAdapter(mLogAdapter); + mListview.setTranscriptMode(ListView.TRANSCRIPT_MODE_ALWAYS_SCROLL); + mListview.setOnItemClickListener(new OnItemClickListener() { + public void onItemClick(AdapterView<?> parent, View view, int position, long id) { + Object listObj = parent.getItemAtPosition(position); + if (listObj instanceof RPCMessage) { + AlertDialog.Builder builder = new AlertDialog.Builder(SyncProxyTester.this); + String rawJSON = ""; + + Integer corrId = -1; + if (listObj instanceof RPCRequest) { + corrId = ((RPCRequest) listObj).getCorrelationID(); + } else if (listObj instanceof RPCResponse) { + corrId = ((RPCResponse) listObj).getCorrelationID(); + } + + try { + rawJSON = ((RPCMessage) listObj).serializeJSON( + mBoundProxyService.syncProxyGetWiProVersion()).toString(2); + builder.setTitle("Raw JSON" + (corrId != -1 ? " (Corr ID " + corrId + ")" : "")); + } catch (Exception e) { + try { + rawJSON = ((RPCMessage) listObj).getFunctionName() + + " (" + ((RPCMessage) listObj).getMessageType() + ")"; + } catch (Exception e1) { + rawJSON = "Undefined"; + } + } + builder.setMessage(rawJSON); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + AlertDialog ad = builder.create(); + ad.show(); + } else if (listObj instanceof String) { + AlertDialog.Builder builder = new AlertDialog.Builder(SyncProxyTester.this); + builder.setMessage(listObj.toString()); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + AlertDialog ad = builder.create(); + ad.show(); + } + } + }); + + if (isFirstActivityRun) { + DialogFragment appSetupDialogFragment = AppSetUpDialog.newInstance(); + appSetupDialogFragment.show(getFragmentManager(), APP_SETUP_DIALOG_TAG); + appSetupDialogFragment.setCancelable(false); + } else { + onSetUpDialogResult(); + } + + loadMessageSelectCount(); + + isFirstActivityRun = false; + } + + public void onSetUpDialogResult() { + setUpReceiver(); + showProtocolPropertiesInTitle(); + if (mBoundProxyService != null) { + initProxyService(); + try { + mBoundProxyService.syncProxyOpenSession(); + } catch (SyncException e) { + Log.e(LOG_TAG, SyncProxyTester.class.getSimpleName() + " syncProxyOpenSession", e); + } + } else { + MainApp.getInstance().bindProxyToMainApp(new IProxyServiceBinder() { + @Override + public void onServiceBindComplete() { + Log.d(LOG_TAG, "Service Bind Complete"); + getProxyService(); + initProxyService(); + + mBoundProxyService.startProxyIfNetworkConnected(); + } + }); + } + } + + private void setUpReceiver() { + IntentFilter intentFilter = new IntentFilter(); + + // provide access to the connection states with a remote device. + //intentFilter.addAction(BluetoothDevice.ACTION_ACL_CONNECTED); + //intentFilter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED); + + intentFilter.addAction(Intent.ACTION_MEDIA_BUTTON); + intentFilter.addAction(AudioManager.ACTION_AUDIO_BECOMING_NOISY); + + if (mSyncReceiver == null) { + mSyncReceiver = new SyncReceiver(); + + mSyncReceiver.setSyncReceiver(new ISyncReceiver() { + @Override + public void onReceive() { + if (mBoundProxyService != null) { + mBoundProxyService.pauseAnnoyingRepetitiveAudio(); + } + } + }); + + if (AppPreferencesManager.getTransportType() == Const.Transport.KEY_BLUETOOTH) { + intentFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED); + if (mBluetoothDeviceManager == null) { + mBluetoothDeviceManager = new BluetoothDeviceManager(); + } + mBluetoothDeviceManager.setBluetoothDeviceManagerCallback(this); + mBluetoothDeviceManager.initState(); + mSyncReceiver.setBluetoothReceiverCallback(mBluetoothDeviceManager); + } + + } + registerReceiver(mSyncReceiver, intentFilter); + } + + @Override + public void onBluetoothDeviceRestoreConnection() { + Log.i(LOG_TAG, "Bluetooth connection restored"); + if (AppPreferencesManager.getTransportType() != Const.Transport.KEY_BLUETOOTH) { + return; + } + // TODO : Consider this case. + /*if (mBoundProxyService == null) { + bindProxyService(this, mProxyServiceConnectionProxy); + }*/ + } + + @Override + public void onBluetoothDeviceTurningOff() { + Log.i(LOG_TAG, "Bluetooth turning off"); + if (AppPreferencesManager.getTransportType() != Const.Transport.KEY_BLUETOOTH) { + return; + } + + if (mBluetoothStopProxyServiceTimeOutHandler == null) { + mBluetoothStopProxyServiceTimeOutHandler = new Handler(); + } else { + mBluetoothStopProxyServiceTimeOutHandler.removeCallbacks( + mBluetoothStopServicePostDelayedCallback); + } + mBluetoothStopProxyServiceTimeOutHandler.postDelayed( + mBluetoothStopServicePostDelayedCallback, EXIT_TIMEOUT); + + if (mBoundProxyService.hasServiceInServicesPool(ServiceType.Audio_Service)) { + stopAudioService(); + } + if (mBoundProxyService.hasServiceInServicesPool(ServiceType.Mobile_Nav)) { + stopMobileNavService(); + } + + if (mBoundProxyService != null) { + mBoundProxyService.destroyService(); + } + } + + @Override + public void onProxyClosed() { + resetAdapters(); + mLogAdapter.logMessage("Disconnected", true); + } + + @Override + public void onPutFileSelected(String fileName) { + if (mPutFileAdapter != null) { + mPutFileAdapter.add(fileName); + } + } + + /** + * Proxy Service Events section + */ + + @Override + public void onDisposeComplete() { + Log.d(LOG_TAG, "Dispose Service complete"); + + if (mBluetoothStopProxyServiceTimeOutHandler != null) { + mBluetoothStopProxyServiceTimeOutHandler.removeCallbacks( + mBluetoothStopServicePostDelayedCallback); + } else { + if (mStopServicesTimeOutHandler != null) { + mStopServicesTimeOutHandler.removeCallbacks(mEndServicesPostDelayedCallback); + } + if (mStopProxyServiceTimeOutHandler != null) { + mStopProxyServiceTimeOutHandler.removeCallbacks(mExitPostDelayedCallback); + } + + if (mStopServicesTimeOutHandler == null && mStopProxyServiceTimeOutHandler == null) { + getExitDialog().dismiss(); + return; + } + + MainApp.getInstance().unbindProxyFromMainApp(); + runInUIThread(new Runnable() { + @Override + public void run() { + getExitDialog().dismiss(); + exitApp(); + } + }); + } + } + + @Override + public void onDisposeError() { + if (mBluetoothStopProxyServiceTimeOutHandler != null) { + mBluetoothStopProxyServiceTimeOutHandler.removeCallbacks( + mBluetoothStopServicePostDelayedCallback); + } + } + + @Override + public void onServiceEnd(ServiceType serviceType) { + mLogAdapter.logMessage("Service '" + serviceType + "' ended"); + + if (mServicesCounter == null) { + Log.w(LOG_TAG, "Service End -> Services counter is NULL"); + executeDestroyService(); + return; + } + int remainServicesNumber = mServicesCounter.decrementAndGet(); + mLogAdapter.logMessage("Services number remained:" + remainServicesNumber); + if (remainServicesNumber == 1) { + executeDestroyService(); + } + } + + @Override + public void onServiceStart(ServiceType serviceType, byte sessionId) { + mLogAdapter.logMessage("Service '" + serviceType + "' started", true); + + if (mBoundProxyService == null) { + mLogAdapter.logMessage(SyncProxyTester.class.getSimpleName() + " '" + serviceType + + "' service can not " + + "start with NULL Proxy Service", Log.WARN); + return; + } + + if (serviceType == ServiceType.Audio_Service) { + MainApp.getInstance().runInUIThread(new Runnable() { + @Override + public void run() { + OutputStream outputStream = mBoundProxyService.syncProxyStartAudioDataTransfer(); + if (outputStream != null) { + AudioServicePreviewFragment fragment = (AudioServicePreviewFragment) + getSupportFragmentManager().findFragmentById(R.id.audioFragment); + fragment.setAudioServiceStateOn(outputStream); + } + } + }); + } else if (serviceType == ServiceType.Mobile_Nav) { + MainApp.getInstance().runInUIThread(new Runnable() { + @Override + public void run() { + OutputStream outputStream = mBoundProxyService.syncProxyStartH264(); + if (outputStream != null) { + MobileNavPreviewFragment fragment = (MobileNavPreviewFragment) + getSupportFragmentManager().findFragmentById(R.id.videoFragment); + fragment.setMobileNaviStateOn(outputStream); + } + } + }); + } else if (serviceType == ServiceType.RPC) { + mServicesCounter.set(0); + rpcSession.setSessionId(sessionId); + } + + mServicesCounter.incrementAndGet(); + } + + @Override + public void onAckReceived(int frameReceived, ServiceType serviceType) { + mLogAdapter.logMessage("Service '" + serviceType + "' Ack received, n:" + frameReceived); + } + + @Override + public void onStartServiceNackReceived(final ServiceType serviceType) { + mLogAdapter.logMessage("Start Service '" + serviceType + "' Nack received", true); + + MainApp.getInstance().runInUIThread(new Runnable() { + @Override + public void run() { + if (serviceType == ServiceType.Mobile_Nav) { + MobileNavPreviewFragment fragment = (MobileNavPreviewFragment) + getSupportFragmentManager().findFragmentById(R.id.videoFragment); + fragment.setStateOff(); + } else if (serviceType == ServiceType.Audio_Service) { + AudioServicePreviewFragment fragment = (AudioServicePreviewFragment) + getSupportFragmentManager().findFragmentById(R.id.audioFragment); + fragment.setStateOff(); + } + } + }); + } + + /** + * Return the next correlation id + * + * @return int + */ + public int getCorrelationid() { + return mAutoIncCorrId++; + } + + private void loadMessageSelectCount() { + SharedPreferences prefs = getSharedPreferences(Const.PREFS_NAME, 0); + messageSelectCount = new Hashtable<String, Integer>(); + for (Entry<String, ?> entry : prefs.getAll().entrySet()) { + if (entry.getKey().startsWith(MSC_PREFIX)) { + messageSelectCount.put(entry.getKey().substring(MSC_PREFIX.length()), + (Integer) entry.getValue()); + } + } + } + + private void saveMessageSelectCount() { + if (messageSelectCount == null) { + return; + } + SharedPreferences.Editor editor = getSharedPreferences(Const.PREFS_NAME, 0).edit(); + for (Entry<String, Integer> entry : messageSelectCount.entrySet()) { + editor.putInt(MSC_PREFIX + entry.getKey(), entry.getValue()); + } + editor.commit(); + } + + private void clearMessageSelectCount() { + messageSelectCount = new Hashtable<String, Integer>(); + SharedPreferences prefs = getSharedPreferences(Const.PREFS_NAME, 0); + SharedPreferences.Editor editor = prefs.edit(); + for (Entry<String, ?> entry : prefs.getAll().entrySet()) { + if (entry.getKey().startsWith(MSC_PREFIX)) { + editor.remove(entry.getKey()); + } + } + editor.commit(); + } + + /** + * Initializes/resets the adapters keeping created submenus, interaction + * choice set ids, etc. + */ + private void resetAdapters() { + // set up storage for subscription records + isButtonSubscribed = new boolean[ButtonName.values().length]; + mButtonAdapter = new ArrayAdapter<ButtonName>(this, + android.R.layout.select_dialog_multichoice, ButtonName.values()) { + public View getView(int position, View convertView, ViewGroup parent) { + CheckedTextView ret = (CheckedTextView) super.getView(position, convertView, parent); + ret.setChecked(isButtonSubscribed[position]); + return ret; + } + }; + + isVehicleDataSubscribed = new boolean[VehicleDataType.values().length]; + + mSubmenuAdapter = new ArrayAdapter<SyncSubMenu>(this, android.R.layout.select_dialog_item); + mSubmenuAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + + mCommandAdapter = new ArrayAdapter<Integer>(this, android.R.layout.select_dialog_item); + mCommandAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + + mCommandIdToParentSubmenuMap = new Hashtable<Integer, Integer>(); + + mChoiceSetAdapter = new ArrayAdapter<Integer>(this, android.R.layout.simple_spinner_item); + mChoiceSetAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + + mPutFileAdapter = new ArrayAdapter<String>(this, android.R.layout.select_dialog_item); + mPutFileAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + } + + /** + * Displays the current protocol properties in the activity's title. + */ + private void showProtocolPropertiesInTitle() { + final SharedPreferences prefs = getSharedPreferences(Const.PREFS_NAME, 0); + int protocolVersion = getCurrentProtocolVersion(); + boolean isMedia = prefs.getBoolean(Const.PREFS_KEY_ISMEDIAAPP, Const.PREFS_DEFAULT_ISMEDIAAPP); + String transportType = null; + switch (prefs.getInt(Const.Transport.PREFS_KEY_TRANSPORT_TYPE, + Const.Transport.PREFS_DEFAULT_TRANSPORT_TYPE)) { + case Const.Transport.KEY_TCP: + transportType = "WiFi"; + break; + case Const.Transport.KEY_BLUETOOTH: + transportType = "BT"; + break; + case Const.Transport.KEY_USB: + transportType = "USB"; + break; + } + setTitle(getResources().getString(R.string.tester_app_name) + " (v" + + protocolVersion + ", " + (isMedia ? "" : "non-") + "media, " + + transportType + ")"); + } + + @Override + public void onDestroy() { + super.onDestroy(); + Log.d(LOG_TAG, SyncProxyTester.class.getSimpleName() + " On Destroy"); + + if (mSyncReceiver != null) { + unregisterReceiver(mSyncReceiver); + } + + removeListeners(); + + //endSyncProxyInstance(); + saveMessageSelectCount(); + _activity = null; + if (mBoundProxyService != null) { + mBoundProxyService.setLogAdapter(null); + } + closeAudioPassThruStream(); + closeAudioPassThruMediaPlayer(); + } + + public Dialog onCreateDialog(int id) { + Dialog dialog = null; + AlertDialog.Builder builder = new AlertDialog.Builder(this); + switch (id) { + case 1: + builder.setTitle("Raw JSON"); + builder.setMessage("This is the raw JSON message here"); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + dialog = builder.create(); + break; + case 2: + break; + default: + dialog = null; + } + return dialog; + } + + /* Creates the menu items */ + public boolean onCreateOptionsMenu(Menu menu) { + boolean result = super.onCreateOptionsMenu(menu); + if (result) { + menu.add(0, PROXY_START, 0, "Proxy Start"); + menu.add(0, MNU_TOGGLE_CONSOLE, 0, "Toggle Console"); + menu.add(0, MNU_CLEAR, 0, "Clear Messages"); + menu.add(0, MNU_EXIT, 0, "Exit"); +/* menu.add(0, MNU_TOGGLE_MEDIA, 0, "Toggle Media");*/ + menu.add(0, MNU_APP_VERSION, 0, "App version"); + menu.add(0, MNU_CLOSESESSION, 0, "Close Session"); + menu.add(0, MNU_HASH_ID_SETUP, 0, "HashId setup"); + menu.add(0, MNU_CLEAR_FUNCTIONS_USAGE, 0, "Reset functions usage"); + menu.add(0, XML_TEST, 0, "XML Test"); + menu.add(0, POLICIES_TEST, 0, "Policies Test"); + menu.add(0, MNU_SET_UP_POLICY_FILES, 0, "Set Up Policy files"); + MenuItem menuitem = menu.add(0, MNU_WAKELOCK, 0, "Lock screen while testing"); + menuitem.setCheckable(true); + menuitem.setChecked(!getDisableLockFlag()); + return true; + } else { + return false; + } + } + + @Override + public boolean onPrepareOptionsMenu(Menu menu) { + MenuItem menuItem = menu.findItem(MNU_WAKELOCK); + if (menuItem != null) { + menuItem.setChecked(!getDisableLockFlag()); + } + return super.onPrepareOptionsMenu(menu); + } + + private int getCurrentProtocolVersion() { + return Const.PROTOCOL_VERSION_2; + } + + private boolean getIsMedia() { + return getSharedPreferences(Const.PREFS_NAME, 0).getBoolean( + Const.PREFS_KEY_ISMEDIAAPP, Const.PREFS_DEFAULT_ISMEDIAAPP); + } + + /* Handles item selections */ + public boolean onOptionsItemSelected(MenuItem item) { + + switch (item.getItemId()) { + case PROXY_START: + BluetoothAdapter mBtAdapter = BluetoothAdapter.getDefaultAdapter(); + if (!mBtAdapter.isEnabled()) { + mBtAdapter.enable(); + } + + /*// TODO : To be reconsider + if (mBoundProxyService == null) { + bindProxyService(this, mProxyServiceConnectionProxy); + } else { + mBoundProxyService.setLogAdapter(mLogAdapter); + }*/ + + if (mBoundProxyService != null) { + mBoundProxyService.reset(); + } + + if (!mBtAdapter.isDiscovering()) { + Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE); + discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300); + startActivity(discoverableIntent); + } + return true; + + case XML_TEST: + xmlTest(); + break; + case POLICIES_TEST: + if (PoliciesTesterActivity.getInstance() == null) { + Intent i = new Intent(this, PoliciesTesterActivity.class); + i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + i.addFlags(Intent.FLAG_ACTIVITY_NO_USER_ACTION); + startActivity(i); + if (_ESN != null) PoliciesTesterActivity.setESN(_ESN); + } + //PoliciesTest.runPoliciesTest(); + break; + case MNU_SET_UP_POLICY_FILES: + DialogFragment mPolicyFilesSetUpDialog = PolicyFilesSetUpDialog.newInstance(); + mPolicyFilesSetUpDialog.show(getFragmentManager(), POLICY_FILES_SETUP_DIALOG_TAG); + break; + case MNU_EXIT: + stopProxyServiceOnExit(); + break; + case MNU_TOGGLE_CONSOLE: + if (_scroller.getVisibility() == ScrollView.VISIBLE) { + _scroller.setVisibility(ScrollView.GONE); + mListview.setVisibility(ListView.VISIBLE); + } else { + _scroller.setVisibility(ScrollView.VISIBLE); + mListview.setVisibility(ListView.GONE); + } + return true; + case MNU_CLEAR: + mLogAdapter.clear(); + return true; + case MNU_TOGGLE_MEDIA: + SharedPreferences settings = getSharedPreferences(Const.PREFS_NAME, 0); + boolean isMediaApp = settings.getBoolean(Const.PREFS_KEY_ISMEDIAAPP, Const.PREFS_DEFAULT_ISMEDIAAPP); + SharedPreferences.Editor editor = settings.edit(); + editor.putBoolean(Const.PREFS_KEY_ISMEDIAAPP, !isMediaApp); + + // Don't forget to commit your edits!!! + editor.commit(); + //super.finish(); + return true; + case MNU_CLOSESESSION: + closeSession(); + return true; + case MNU_APP_VERSION: { + showAppVersion(); + break; + } + case MNU_CLEAR_FUNCTIONS_USAGE: + clearMessageSelectCount(); + break; + case MNU_WAKELOCK: + toggleDisableLock(); + break; + case MNU_HASH_ID_SETUP: + DialogFragment hashIdSetUpDialog = HashIdSetUpDialog.newInstance(); + hashIdSetUpDialog.show(getFragmentManager(), HASH_ID_SET_UP_DIALOG_TAG); + break; + } + + return false; + } + + private void closeSession() { + if (mBoundProxyService != null) { + mBoundProxyService.setCloseSessionCallback(new ICloseSession() { + @Override + public void onCloseSessionComplete() { + finishActivity(); + } + }); + mBoundProxyService.syncProxyCloseSession(true); + } + } + + private void finishActivity() { + super.finish(); + } + + private void xmlTest() { + openXmlFilePathDialog(); + } + + private void xmlTestContinue(String filePath) { + if (_testerMain != null) { + _testerMain.restart(filePath); + Toast.makeText(getApplicationContext(), "start your engines", Toast.LENGTH_SHORT).show(); + } else { + mBoundProxyService.startModuleTest(); + _testerMain.restart(filePath); + Toast.makeText(getApplicationContext(), "Start the app on SYNC first", Toast.LENGTH_LONG).show(); + } + } + + /** + * Toggles the current state of the disable lock when testing flag, and + * writes it to the preferences. + */ + private void toggleDisableLock() { + SharedPreferences prefs = getSharedPreferences(Const.PREFS_NAME, 0); + boolean disableLock = prefs.getBoolean( + Const.PREFS_KEY_DISABLE_LOCK_WHEN_TESTING, + Const.PREFS_DEFAULT_DISABLE_LOCK_WHEN_TESTING); + disableLock = !disableLock; + prefs.edit() + .putBoolean(Const.PREFS_KEY_DISABLE_LOCK_WHEN_TESTING, + disableLock).commit(); + } + + /** + * Returns the current state of the disable lock when testing flag. + * + * @return true if the screen lock is disabled + */ + public boolean getDisableLockFlag() { + return getSharedPreferences(Const.PREFS_NAME, 0).getBoolean( + Const.PREFS_KEY_DISABLE_LOCK_WHEN_TESTING, + Const.PREFS_DEFAULT_DISABLE_LOCK_WHEN_TESTING); + } + + private String getAssetsContents(String filename, String defaultString) { + StringBuilder builder = new StringBuilder(); + BufferedReader reader = null; + try { + reader = new BufferedReader(new InputStreamReader(getAssets().open( + filename))); + String line; + while ((line = reader.readLine()) != null) { + builder.append(line + "\n"); + } + } catch (IOException e) { + Log.d(LOG_TAG, "Can't open file with build info", e); + } finally { + if (reader != null) { + try { + reader.close(); + } catch (IOException e) { + Log.e(LOG_TAG, e.toString()); + } + } + } + return builder.length() > 0 ? builder.toString().trim() : defaultString; + } + + private void showAppVersion() { + String appVersion; + int appCode = 0; + try { + appVersion = getPackageManager() + .getPackageInfo(getPackageName(), 0).versionName; + appCode = getPackageManager() + .getPackageInfo(getPackageName(), 0).versionCode; + } catch (NameNotFoundException e) { + Log.d(LOG_TAG, "Can't get package info", e); + appVersion = "Unknown"; + } + String buildInfo = getAssetsContents("build.info", + "Build info not available"); + String changelog = getAssetsContents("CHANGELOG.txt", + "Changelog not available"); + + new AlertDialog.Builder(this) + .setTitle("App version") + .setMessage("Ver:" + appVersion + ", " + "Code:" + String.valueOf(appCode) + "\n" + + buildInfo + "\n\nCHANGELOG:\n" + changelog) + .setNeutralButton(android.R.string.ok, null).create().show(); + } + +/* public void startSyncProxyService() { + // Get the local Bluetooth adapter + BluetoothAdapter mBtAdapter = BluetoothAdapter.getDefaultAdapter(); + + //BT Adapter exists, is enabled, and there are paired devices with the name SYNC + //Ideally start service and start proxy if already connected to sync + //but, there is no way to tell if a device is currently connected (pre OS 4.0) + + if (mBtAdapter != null) + { + if ((mBtAdapter.isEnabled() && mBtAdapter.getBondedDevices().isEmpty() != true)) + { + // Get a set of currently paired devices + Set<BluetoothDevice> pairedDevices = mBtAdapter.getBondedDevices(); + + boolean isSYNCpaired = false; + // Check if there is a paired device with the name "SYNC" + if (pairedDevices.size() > 0) { + for (BluetoothDevice device : pairedDevices) { + if (device.getName().toString().equals("SYNC")) { + isSYNCpaired = true; + break; + } + } + } else { + Log.i("TAG", "A No Paired devices with the name sync"); + } + + if (isSYNCpaired == true) { + _applinkService = new ProxyService(); + if (ProxyService.getInstance() == null) { + Intent startIntent = new Intent(this, ProxyService.class); + startService(startIntent); + //bindService(startIntent, this, Context.BIND_AUTO_CREATE); + } else { + // need to get the instance and add myself as a listener + ProxyService.getInstance().setLogAdapter(this); + } + } + } + } + }*/ + + /** + * Adds the function name to the adapter. + */ + private void addToFunctionsAdapter(ArrayAdapter<String> adapter, String functionName) { + adapter.add(functionName); + } + + public void onClick(View v) { + if (v == findViewById(R.id.btnSendMessage)) { + final ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.select_dialog_item); + addToFunctionsAdapter(adapter, Names.Alert); + addToFunctionsAdapter(adapter, Names.Speak); + addToFunctionsAdapter(adapter, Names.Show); + addToFunctionsAdapter(adapter, ButtonSubscriptions); + addToFunctionsAdapter(adapter, Names.AddCommand); + addToFunctionsAdapter(adapter, Names.DeleteCommand); + addToFunctionsAdapter(adapter, Names.AddSubMenu); + addToFunctionsAdapter(adapter, Names.DeleteSubMenu); + addToFunctionsAdapter(adapter, Names.SetGlobalProperties); + addToFunctionsAdapter(adapter, Names.ResetGlobalProperties); + addToFunctionsAdapter(adapter, Names.SetMediaClockTimer); + addToFunctionsAdapter(adapter, Names.CreateInteractionChoiceSet); + addToFunctionsAdapter(adapter, Names.DeleteInteractionChoiceSet); + addToFunctionsAdapter(adapter, Names.PerformInteraction); + addToFunctionsAdapter(adapter, Names.EncodedSyncPData); + addToFunctionsAdapter(adapter, Names.SyncPData); + addToFunctionsAdapter(adapter, Names.Slider); + addToFunctionsAdapter(adapter, Names.ScrollableMessage); + addToFunctionsAdapter(adapter, Names.ChangeRegistration); + addToFunctionsAdapter(adapter, Names.PutFile); + addToFunctionsAdapter(adapter, Names.DeleteFile); + addToFunctionsAdapter(adapter, Names.ListFiles); + addToFunctionsAdapter(adapter, Names.SetAppIcon); + addToFunctionsAdapter(adapter, Names.PerformAudioPassThru); + addToFunctionsAdapter(adapter, Names.EndAudioPassThru); + addToFunctionsAdapter(adapter, VehicleDataSubscriptions); + addToFunctionsAdapter(adapter, Names.GetVehicleData); + addToFunctionsAdapter(adapter, Names.ReadDID); + addToFunctionsAdapter(adapter, Names.GetDTCs); + addToFunctionsAdapter(adapter, Names.ShowConstantTBT); + addToFunctionsAdapter(adapter, Names.UpdateTurnList); + addToFunctionsAdapter(adapter, Names.SetDisplayLayout); + addToFunctionsAdapter(adapter, Names.DiagnosticMessage); + addToFunctionsAdapter(adapter, Names.RegisterAppInterface); + addToFunctionsAdapter(adapter, Names.UnregisterAppInterface); + addToFunctionsAdapter(adapter, GenericRequest.NAME); + + adapter.sort(new Comparator<String>() { + @Override + public int compare(String lhs, String rhs) { + // compare based on the number of selections so far + Integer lCount = messageSelectCount.get(lhs); + if (lCount == null) { + lCount = 0; + } + Integer rCount = messageSelectCount.get(rhs); + if (rCount == null) { + rCount = 0; + } + return rCount - lCount; + } + }); + + new AlertDialog.Builder(this) + .setTitle("Pick a Function") + .setAdapter(adapter, new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + if (adapter.getItem(which).equals(Names.Alert)) { + sendAlert(); + } else if (adapter.getItem(which).equals(Names.Speak)) { + //something + AlertDialog.Builder builder; + AlertDialog dlg; + + Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.speak, null); + final EditText txtSpeakText1 = (EditText) layout.findViewById(R.id.txtSpeakText1); + final EditText txtSpeakText2 = (EditText) layout.findViewById(R.id.txtSpeakText2); + final EditText txtSpeakText3 = (EditText) layout.findViewById(R.id.txtSpeakText3); + final EditText txtSpeakText4 = (EditText) layout.findViewById(R.id.txtSpeakText4); + + final Spinner spnSpeakType1 = (Spinner) layout.findViewById(R.id.spnSpeakType1); + final Spinner spnSpeakType2 = (Spinner) layout.findViewById(R.id.spnSpeakType2); + final Spinner spnSpeakType3 = (Spinner) layout.findViewById(R.id.spnSpeakType3); + final Spinner spnSpeakType4 = (Spinner) layout.findViewById(R.id.spnSpeakType4); + + ArrayAdapter<SpeechCapabilities> speechSpinnerAdapter = new ArrayAdapter<SpeechCapabilities>( + adapter.getContext(), android.R.layout.simple_spinner_item, SpeechCapabilities.values()); + int textCapabilityPos = speechSpinnerAdapter.getPosition(SpeechCapabilities.TEXT); + spnSpeakType1.setAdapter(speechSpinnerAdapter); + spnSpeakType1.setSelection(textCapabilityPos); + spnSpeakType2.setAdapter(speechSpinnerAdapter); + spnSpeakType2.setSelection(textCapabilityPos); + spnSpeakType3.setAdapter(speechSpinnerAdapter); + spnSpeakType3.setSelection(textCapabilityPos); + spnSpeakType4.setAdapter(speechSpinnerAdapter); + spnSpeakType4.setSelection(textCapabilityPos); + + builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + Speak msg = new Speak(); + msg.setCorrelationID(getCorrelationid()); + String speak1 = txtSpeakText1.getText().toString(); + String speak2 = txtSpeakText2.getText().toString(); + String speak3 = txtSpeakText3.getText().toString(); + String speak4 = txtSpeakText4.getText().toString(); + Vector<TTSChunk> chunks = new Vector<TTSChunk>(); + + if (speak1.length() > 0) { + chunks.add(TTSChunkFactory.createChunk((SpeechCapabilities) spnSpeakType1.getSelectedItem(), speak1)); + } + if (speak2.length() > 0) { + chunks.add(TTSChunkFactory.createChunk((SpeechCapabilities) spnSpeakType2.getSelectedItem(), speak2)); + } + if (speak3.length() > 0) { + chunks.add(TTSChunkFactory.createChunk((SpeechCapabilities) spnSpeakType3.getSelectedItem(), speak3)); + } + if (speak4.length() > 0) { + chunks.add(TTSChunkFactory.createChunk(SpeechCapabilities.SAPI_PHONEMES, speak4)); + } + msg.setTtsChunks(chunks); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + builder.setView(layout); + dlg = builder.create(); + dlg.show(); + } else if (adapter.getItem(which).equals(Names.Show)) { + sendShow(); + } else if (adapter.getItem(which).equals(ButtonSubscriptions)) { + //something + AlertDialog.Builder builder = new AlertDialog.Builder(adapter.getContext()); + builder.setAdapter(mButtonAdapter, new DialogInterface.OnClickListener() { + + public void onClick(DialogInterface dialog, int which) { + boolean needToSubscribe = !isButtonSubscribed[which]; + ButtonName buttonName = ButtonName.values()[which]; + int corrId = getCorrelationid(); + if (needToSubscribe) { + if (mBoundProxyService != null) { + mBoundProxyService.commandSubscribeButtonResumable( + buttonName, corrId); + } + } else { + UnsubscribeButton msg = new UnsubscribeButton(); + msg.setCorrelationID(corrId); + msg.setButtonName(buttonName); + mLogAdapter.logMessage(msg, true); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } + isButtonSubscribed[which] = !isButtonSubscribed[which]; + } + }); + AlertDialog dlg = builder.create(); + dlg.show(); + } else if (adapter.getItem(which).equals(Names.AddCommand)) { + sendAddCommand(); + } else if (adapter.getItem(which).equals(Names.DeleteCommand)) { + sendDeleteCommand(); + } else if (adapter.getItem(which).equals(Names.AddSubMenu)) { + sendAddSubmenu(); + } else if (adapter.getItem(which).equals(Names.DeleteSubMenu)) { + sendDeleteSubMenu(); + } else if (adapter.getItem(which).equals(Names.SetGlobalProperties)) { + sendSetGlobalProperties(); + } else if (adapter.getItem(which).equals(Names.ResetGlobalProperties)) { + sendResetGlobalProperties(); + } else if (adapter.getItem(which).equals(Names.SetMediaClockTimer)) { + sendSetMediaClockTimer(); + } else if (adapter.getItem(which).equals(Names.CreateInteractionChoiceSet)) { + sendCreateInteractionChoiceSet(); + } else if (adapter.getItem(which).equals(Names.DeleteInteractionChoiceSet)) { + //something + AlertDialog.Builder builder = new AlertDialog.Builder(adapter.getContext()); + builder.setAdapter(mChoiceSetAdapter, new DialogInterface.OnClickListener() { + + public void onClick(DialogInterface dialog, int which) { + DeleteInteractionChoiceSet msg = new DeleteInteractionChoiceSet(); + msg.setCorrelationID(getCorrelationid()); + int commandSetID = mChoiceSetAdapter.getItem(which); + msg.setInteractionChoiceSetID(commandSetID); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + if (_latestDeleteChoiceSetId != CHOICESETID_UNSET) { + Log.w(LOG_TAG, "Latest deleteChoiceSetId should be unset, but equals to " + _latestDeleteChoiceSetId); + } + _latestDeleteChoiceSetId = commandSetID; + } + }); + AlertDialog dlg = builder.create(); + dlg.show(); + } else if (adapter.getItem(which).equals(Names.PerformInteraction)) { + sendPerformInteraction(); + } else if (adapter.getItem(which).equals(Names.EncodedSyncPData)) { + sendSyncPData(true); + } else if (adapter.getItem(which).equals(Names.SyncPData)) { + sendSyncPData(false); + } else if (adapter.getItem(which).equals(Names.Slider)) { + sendSlider(); + } else if (adapter.getItem(which).equals(Names.ScrollableMessage)) { + //something + AlertDialog.Builder builder; + AlertDialog dlg; + + final Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.scrollablemessage, null); + final EditText txtScrollableMessageBody = (EditText) layout.findViewById(R.id.txtScrollableMessageBody); + chkIncludeSoftButtons = (CheckBox) layout.findViewById(R.id.chkIncludeSBs); + final EditText txtTimeout = (EditText) layout.findViewById(R.id.scrollablemessage_editTimeout); + + SoftButton sb1 = new SoftButton(); + sb1.setSoftButtonID(SyncProxyTester.getNewSoftButtonId()); + sb1.setText("Reply"); + sb1.setType(SoftButtonType.SBT_TEXT); + sb1.setIsHighlighted(false); + sb1.setSystemAction(SystemAction.STEAL_FOCUS); + SoftButton sb2 = new SoftButton(); + sb2.setSoftButtonID(SyncProxyTester.getNewSoftButtonId()); + sb2.setText("Close"); + sb2.setType(SoftButtonType.SBT_TEXT); + sb2.setIsHighlighted(false); + sb2.setSystemAction(SystemAction.DEFAULT_ACTION); + currentSoftButtons = new Vector<SoftButton>(); + currentSoftButtons.add(sb1); + currentSoftButtons.add(sb2); + + Button btnSoftButtons = (Button) layout.findViewById(R.id.scrollablemessage_btnSoftButtons); + btnSoftButtons.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + IntentHelper.addObjectForKey(currentSoftButtons, + Const.INTENTHELPER_KEY_OBJECTSLIST); + Intent intent = new Intent(mContext, SoftButtonsListActivity.class); + intent.putExtra(Const.INTENT_KEY_OBJECTS_MAXNUMBER, + SCROLLABLEMESSAGE_MAXSOFTBUTTONS); + startActivityForResult(intent, REQUEST_LIST_SOFTBUTTONS); + } + }); + + builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + ScrollableMessage msg = new ScrollableMessage(); + msg.setCorrelationID(getCorrelationid()); + try { + msg.setTimeout(Integer.parseInt(txtTimeout.getText().toString())); + } catch (NumberFormatException e) { + // do nothing, leave the default timeout + } + msg.setScrollableMessageBody(txtScrollableMessageBody.getEditableText().toString()); + if (chkIncludeSoftButtons.isChecked() && + (currentSoftButtons != null) && + (currentSoftButtons.size() > 0)) { + msg.setSoftButtons(currentSoftButtons); + } + currentSoftButtons = null; + chkIncludeSoftButtons = null; + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + currentSoftButtons = null; + chkIncludeSoftButtons = null; + dialog.cancel(); + } + }); + builder.setView(layout); + dlg = builder.create(); + dlg.show(); + } else if (adapter.getItem(which).equals(Names.ChangeRegistration)) { + //ChangeRegistration + AlertDialog.Builder builder; + AlertDialog dlg; + + Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.changeregistration, null); + + final Spinner spnLanguage = (Spinner) layout.findViewById(R.id.spnLanguage); + ArrayAdapter<Language> spinnerAdapterLanguage = new ArrayAdapter<Language>(adapter.getContext(), + android.R.layout.simple_spinner_item, Language.values()); + spinnerAdapterLanguage.setDropDownViewResource( + android.R.layout.simple_spinner_dropdown_item); + spnLanguage.setAdapter(spinnerAdapterLanguage); + + final Spinner spnHmiDisplayLanguage = (Spinner) layout.findViewById(R.id.spnHmiDisplayLanguage); + ArrayAdapter<Language> spinnerAdapterHmiDisplayLanguage = new ArrayAdapter<Language>(adapter.getContext(), + android.R.layout.simple_spinner_item, Language.values()); + spinnerAdapterHmiDisplayLanguage.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + spnHmiDisplayLanguage.setAdapter(spinnerAdapterHmiDisplayLanguage); + + builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + ChangeRegistration msg = new ChangeRegistration(); + msg.setLanguage((Language) spnLanguage.getSelectedItem()); + msg.setHmiDisplayLanguage((Language) spnHmiDisplayLanguage.getSelectedItem()); + msg.setCorrelationID(getCorrelationid()); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + builder.setView(layout); + dlg = builder.create(); + dlg.show(); + } else if (adapter.getItem(which).equals(Names.PutFile)) { + DialogFragment putFileDialogFragment = PutFileDialog.newInstance(getCorrelationid()); + putFileDialogFragment.show(getFragmentManager(), PUT_FILE_DIALOG_TAG); + } else if (adapter.getItem(which).equals(Names.DeleteFile)) { + //DeleteFile + AlertDialog.Builder builder = new AlertDialog.Builder(adapter.getContext()); + builder.setAdapter(mPutFileAdapter, new DialogInterface.OnClickListener() { + + public void onClick(DialogInterface dialog, int which) { + String syncFileName = mPutFileAdapter.getItem(which); + DeleteFile msg = new DeleteFile(); + msg.setSyncFileName(syncFileName); + msg.setCorrelationID(getCorrelationid()); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + mPutFileAdapter.remove(syncFileName); + } + }); + AlertDialog dlg = builder.create(); + dlg.show(); + } else if (adapter.getItem(which).equals(Names.ListFiles)) { + //ListFiles + if (mBoundProxyService != null) { + mBoundProxyService.commandListFiles(); + } + } else if (adapter.getItem(which).equals(Names.SetAppIcon)) { + //SetAppIcon + AlertDialog.Builder builder; + AlertDialog dlg; + + Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.setappicon, null); + + final EditText txtSyncFileName = (EditText) layout.findViewById(R.id.syncFileNameIcon); + + builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + String syncFileName = txtSyncFileName.getText().toString(); + SetAppIcon msg = new SetAppIcon(); + msg.setSyncFileName(syncFileName); + msg.setCorrelationID(getCorrelationid()); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + builder.setView(layout); + dlg = builder.create(); + dlg.show(); + } else if (adapter.getItem(which).equals(Names.PerformAudioPassThru)) { + sendPerformAudioPassThru(); + } else if (adapter.getItem(which).equals(Names.EndAudioPassThru)) { + //EndAudioPassThru + EndAudioPassThru msg = new EndAudioPassThru(); + msg.setCorrelationID(getCorrelationid()); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } else if (adapter.getItem(which).equals(VehicleDataSubscriptions)) { + sendVehicleDataSubscriptions(); + } else if (adapter.getItem(which).equals(Names.GetVehicleData)) { + sendGetVehicleData(); + } else if (adapter.getItem(which).equals(Names.ReadDID)) { + //ReadDID + AlertDialog.Builder builder; + AlertDialog dlg; + + final Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.readdid, null); + + final EditText txtECUNameDID = (EditText) layout.findViewById(R.id.txtECUNameDID); + final EditText txtDIDLocation = (EditText) layout.findViewById(R.id.txtDIDLocation); + + builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + try { + Vector<Integer> didlocations = new Vector<Integer>(); + didlocations.add(Integer.parseInt(txtDIDLocation.getText().toString())); + ReadDID msg = new ReadDID(); + msg.setEcuName(Integer.parseInt(txtECUNameDID.getText().toString())); + msg.setDidLocation(didlocations); + msg.setCorrelationID(getCorrelationid()); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } catch (NumberFormatException e) { + SafeToast.showToastAnyThread("Couldn't parse number"); + } + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + builder.setView(layout); + dlg = builder.create(); + dlg.show(); + } else if (adapter.getItem(which).equals(Names.GetDTCs)) { + sendGetDTCs(); + } else if (adapter.getItem(which).equals(Names.ShowConstantTBT)) { + sendShowConstantTBT(); + } else if (adapter.getItem(which).equals(Names.UpdateTurnList)) { + sendUpdateTurnList(); + } else if (adapter.getItem(which).equals(Names.SetDisplayLayout)) { + sendSetDisplayLayout(); + } else if (adapter.getItem(which).equals(Names.UnregisterAppInterface)) { + sendUnregisterAppInterface(); + } else if (adapter.getItem(which).equals(Names.RegisterAppInterface)) { + sendRegisterAppInterface(); + } else if (adapter.getItem(which).equals(Names.DiagnosticMessage)) { + sendDiagnosticMessage(); + } else if (adapter.getItem(which).equals(GenericRequest.NAME)) { + sendGenericRequest(); + } + + String function = adapter.getItem(which); + Integer curCount = messageSelectCount.get(function); + if (curCount == null) { + curCount = 0; + } + messageSelectCount.put(function, curCount + 1); + } + + /** + * Opens the UI for DeleteCommand and sends it. + */ + private void sendDeleteCommand() { + AlertDialog.Builder builder = new AlertDialog.Builder(adapter.getContext()); + builder.setAdapter(mCommandAdapter, new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, int which) { + DeleteCommand msg = new DeleteCommand(); + msg.setCorrelationID(getCorrelationid()); + int cmdID = mCommandAdapter.getItem(which); + msg.setCmdID(cmdID); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + + if (_latestDeleteCommandCmdID != null) { + Log.w(LOG_TAG, + "Latest deleteCommand should be null, but it is " + + _latestDeleteCommandCmdID); + } + _latestDeleteCommandCmdID = cmdID; + } + }); + builder.show(); + } + + /** + * Sends Alert message. + */ + private void sendAlert() { + final Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.alert, null); + final EditText txtSpeak = (EditText) layout.findViewById(R.id.txtSpeak); + final EditText txtAlertField1 = (EditText) layout.findViewById(R.id.txtAlertField1); + final EditText txtAlertField2 = (EditText) layout.findViewById(R.id.txtAlertField2); + final EditText txtAlertField3 = (EditText) layout.findViewById(R.id.txtAlertField3); + final EditText txtDuration = (EditText) layout.findViewById(R.id.txtDuration); + final CheckBox chkPlayTone = (CheckBox) layout.findViewById(R.id.chkPlayTone); + final CheckBox useProgressIndicator = (CheckBox) layout.findViewById(R.id.alert_useProgressIndicator); + final CheckBox useDuration = (CheckBox) layout.findViewById(R.id.alert_useDuration); + + chkIncludeSoftButtons = (CheckBox) layout.findViewById(R.id.chkIncludeSBs); + + SoftButton sb1 = new SoftButton(); + sb1.setSoftButtonID( + SyncProxyTester.getNewSoftButtonId()); + sb1.setText("ReRoute"); + sb1.setType(SoftButtonType.SBT_TEXT); + sb1.setIsHighlighted(false); + sb1.setSystemAction(SystemAction.STEAL_FOCUS); + SoftButton sb2 = new SoftButton(); + sb2.setSoftButtonID(SyncProxyTester.getNewSoftButtonId()); + sb2.setText("Close"); + sb2.setType(SoftButtonType.SBT_TEXT); + sb2.setIsHighlighted(false); + sb2.setSystemAction(SystemAction.DEFAULT_ACTION); + currentSoftButtons = new Vector<SoftButton>(); + currentSoftButtons.add(sb1); + currentSoftButtons.add(sb2); + + Button btnSoftButtons = (Button) layout.findViewById(R.id.alert_btnSoftButtons); + btnSoftButtons.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + IntentHelper + .addObjectForKey(currentSoftButtons, + Const.INTENTHELPER_KEY_OBJECTSLIST); + Intent intent = new Intent(mContext, SoftButtonsListActivity.class); + intent.putExtra(Const.INTENT_KEY_OBJECTS_MAXNUMBER, ALERT_MAXSOFTBUTTONS); + startActivityForResult(intent, REQUEST_LIST_SOFTBUTTONS); + } + }); + + AlertDialog.Builder builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + try { + Alert msg = new Alert(); + msg.setCorrelationID(getCorrelationid()); + msg.setAlertText1(txtAlertField1.getText().toString()); + msg.setAlertText2(txtAlertField2.getText().toString()); + msg.setAlertText3(txtAlertField3.getText().toString()); + if (useDuration.isChecked()) { + msg.setDuration(Integer.parseInt(txtDuration.getText().toString())); + } + msg.setPlayTone(chkPlayTone.isChecked()); + msg.setProgressIndicator(useProgressIndicator.isChecked()); + + String toSpeak = txtSpeak.getText().toString(); + if (toSpeak.length() > 0) { + Vector<TTSChunk> ttsChunks = TTSChunkFactory + .createSimpleTTSChunks( + toSpeak); + msg.setTtsChunks(ttsChunks); + } + if (chkIncludeSoftButtons.isChecked() && + (currentSoftButtons != null) && + (currentSoftButtons.size() > 0)) { + msg.setSoftButtons(currentSoftButtons); + } + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } catch (NumberFormatException e) { + SafeToast.showToastAnyThread("Couldn't parse number"); + } + currentSoftButtons = null; + chkIncludeSoftButtons = null; + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + currentSoftButtons = null; + chkIncludeSoftButtons = null; + dialog.cancel(); + } + }); + builder.setView(layout); + builder.show(); + } + + /** + * Sends UnregisterAppInterface message. + */ + private void sendUnregisterAppInterface() { + UnregisterAppInterface msg = new UnregisterAppInterface(); + msg.setCorrelationID(getCorrelationid()); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } + + /** + * Opens the dialog for DeleteSubMenu message and sends it. + */ + private void sendDeleteSubMenu() { + AlertDialog.Builder builder = + new AlertDialog.Builder(adapter.getContext()); + builder.setAdapter(mSubmenuAdapter, + new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, + int which) { + SyncSubMenu menu = + mSubmenuAdapter.getItem(which); + DeleteSubMenu msg = new DeleteSubMenu(); + msg.setCorrelationID(getCorrelationid()); + msg.setMenuID(menu.getSubMenuId()); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + + if (_latestDeleteSubmenu != null) { + Log.w(LOG_TAG, + "Latest deleteSubmenu should be null, but equals to " + + _latestDeleteSubmenu); + } + _latestDeleteSubmenu = menu; + } + }); + builder.show(); + } + + /** + * Opens the dialog for GetVehicleData message and sends it. + */ + private void sendGetVehicleData() { + AlertDialog.Builder builder = new AlertDialog.Builder(adapter.getContext()); + builder.setAdapter(_vehicleDataType, new DialogInterface.OnClickListener() { + + public void onClick(DialogInterface dialog, int which) { + GetVehicleData msg = new GetVehicleData(); + + final String[] methodNames = + { "Gps", "Speed", "Rpm", + "FuelLevel", + "FuelLevel_State", + "InstantFuelConsumption", + "ExternalTemperature", + "Vin", "Prndl", + "TirePressure", + "Odometer", + "BeltStatus", + "BodyInformation", + "DeviceStatus", + "DriverBraking", + "WiperStatus", + "HeadLampStatus", + "BatteryVoltage", + "EngineTorque", + "AccPedalPosition", + "SteeringWheelAngle", + "ECallInfo", + "AirbagStatus", + "EmergencyEvent", + "ClusterModeStatus", + "MyKey" }; + final String setterName = "set" + methodNames[which]; + setVehicleDataParam(msg, GetVehicleData.class, setterName); + + msg.setCorrelationID(getCorrelationid()); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } + }); + builder.show(); + } + + /** + * Opens the dialog for GetDTCs message and sends it. + */ + private void sendGetDTCs() { + final Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.getdtcs, null); + + final EditText txtECUNameDTC = (EditText) layout.findViewById(R.id.getdtcs_txtECUNameDTC); + final EditText txtdtcMask = (EditText) layout.findViewById(R.id.getdtcs_dtcMask); + + AlertDialog.Builder builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + try { + GetDTCs msg = new GetDTCs(); + msg.setEcuName(Integer.parseInt(txtECUNameDTC.getText().toString())); + msg.setDTCMask(Integer.parseInt(txtdtcMask.getText().toString())); + msg.setCorrelationID(getCorrelationid()); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } catch (NumberFormatException e) { + SafeToast.showToastAnyThread("Couldn't parse number"); + } + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + builder.setView(layout); + builder.show(); + } + + /** + * Opens the dialog for PerformAudioPassThru message and sends it. + */ + private void sendPerformAudioPassThru() { + final Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.performaudiopassthru, null); + + final EditText txtInitialPrompt = (EditText) layout + .findViewById(R.id.performaudiopassthru_txtInitialPrompt); + final EditText txtAudioPassThruDisplayText1 = (EditText) layout + .findViewById(R.id.performaudiopassthru_txtAudioPassThruDisplayText1); + final EditText txtAudioPassThruDisplayText2 = (EditText) layout + .findViewById(R.id.performaudiopassthru_txtAudioPassThruDisplayText2); + final Spinner spnSamplingRate = (Spinner) layout + .findViewById(R.id.performaudiopassthru_spnSamplingRate); + final EditText txtMaxDuration = (EditText) layout + .findViewById(R.id.performaudiopassthru_txtMaxDuration); + final Spinner spnBitsPerSample = (Spinner) layout + .findViewById(R.id.performaudiopassthru_spnBitsPerSample); + final Spinner spnAudioType = (Spinner) layout + .findViewById(R.id.performaudiopassthru_spnAudioType); + final CheckBox chkMuteAudio = (CheckBox) layout + .findViewById(R.id.performaudiopassthru_muteAudio); + + ArrayAdapter<SamplingRate> spinnerAdapterSamplingRate = new ArrayAdapter<SamplingRate>( + adapter.getContext(), + android.R.layout.simple_spinner_item, SamplingRate.values()); + spinnerAdapterSamplingRate + .setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + spnSamplingRate.setAdapter(spinnerAdapterSamplingRate); + + ArrayAdapter<BitsPerSample> spinnerAdapterBitsPerSample = new ArrayAdapter<BitsPerSample>( + adapter.getContext(), + android.R.layout.simple_spinner_item, BitsPerSample.values()); + spinnerAdapterBitsPerSample + .setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + spnBitsPerSample.setAdapter(spinnerAdapterBitsPerSample); + + ArrayAdapter<AudioType> spinnerAdapterAudioType = new ArrayAdapter<AudioType>( + adapter.getContext(), + android.R.layout.simple_spinner_item, AudioType.values()); + spinnerAdapterAudioType.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + spnAudioType.setAdapter(spinnerAdapterAudioType); + + AlertDialog.Builder builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + Vector<TTSChunk> initChunks = TTSChunkFactory + .createSimpleTTSChunks(txtInitialPrompt.getText().toString()); + try { + PerformAudioPassThru msg = new PerformAudioPassThru(); + msg.setInitialPrompt(initChunks); + msg.setAudioPassThruDisplayText1(txtAudioPassThruDisplayText1.getText().toString()); + msg.setAudioPassThruDisplayText2(txtAudioPassThruDisplayText2.getText().toString()); + msg.setSamplingRate((SamplingRate) spnSamplingRate.getSelectedItem()); + msg.setMaxDuration(Integer.parseInt(txtMaxDuration.getText().toString())); + msg.setBitsPerSample((BitsPerSample) spnBitsPerSample.getSelectedItem()); + msg.setAudioType((AudioType) spnAudioType.getSelectedItem()); + msg.setMuteAudio(chkMuteAudio.isChecked()); + msg.setCorrelationID(getCorrelationid()); + latestPerformAudioPassThruMsg = msg; + mLogAdapter.logMessage(msg, true); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } catch (NumberFormatException e) { + SafeToast.showToastAnyThread("Couldn't parse number"); + } + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + builder.setView(layout); + builder.show(); + } + + /** + * Opens the dialog for AddSubMenu message and sends it. + */ + private void sendAddSubmenu() { + DialogFragment addSubMenuDialogFragment = AddSubMenuDialog.newInstance(); + addSubMenuDialogFragment.show(getFragmentManager(), ADD_SUB_MENU_DIALOG_TAG); + } + + /** + * Opens the dialog for AddCommand message and sends it. + */ + private void sendAddCommand() { + DialogFragment addCommandDialogFragment = AddCommandDialog.newInstance(); + addCommandDialogFragment.show(getFragmentManager(), ADD_COMMAND_DIALOG_TAG); + } + + /** + * Opens the dialog for SyncPData or EncodedSyncPData message and sends it. + * @param sendEncoded true to send EncodedSyncPData message; SyncPData otherwise + */ + private void sendSyncPData(final Boolean sendEncoded) { + final Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.encodedsyncpdata, null); + + txtLocalFileName = (EditText) layout.findViewById(R.id.encodedsyncpdata_localFileName); + final Button btnSelectLocalFile = (Button) layout.findViewById(R.id.encodedsyncpdata_selectFileButton); + btnSelectLocalFile.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + // show Choose File dialog + Intent intent = new Intent(mContext, FileDialog.class); + intent.putExtra(FileDialog.START_PATH, "/sdcard"); + intent.putExtra(FileDialog.CAN_SELECT_DIR, false); + intent.putExtra(FileDialog.SELECTION_MODE, SelectionMode.MODE_OPEN); + startActivityForResult(intent, Const.REQUEST_FILE_OPEN); + } + }); + + AlertDialog.Builder builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, int id) { + String filename = txtLocalFileName.getText().toString(); + byte[] data = AppUtils.contentsOfResource(filename); + if (data != null) { + RPCRequest request = null; + if (sendEncoded) { + String base64Data = Base64.encodeBytes(data); + EncodedSyncPData msg = new EncodedSyncPData(); + Vector<String> syncPData = new Vector<String>(); + syncPData.add(base64Data); + msg.setData(syncPData); + msg.setCorrelationID(getCorrelationid()); + request = msg; + } else { + SyncPData msg = new SyncPData(); + msg.setCorrelationID(getCorrelationid()); + msg.setBulkData(data); + request = msg; + } + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(request); + } + } else { + Toast.makeText(mContext, "Can't read data from file", Toast.LENGTH_LONG).show(); + } + txtLocalFileName = null; + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + txtLocalFileName = null; + dialog.cancel(); + } + }); + builder.setView(layout); + builder.show(); + } + + /** + * Opens the dialog for ShowConstantTBT message and sends it. + */ + private void sendShowConstantTBT() { + final Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.showconstanttbt, + (ViewGroup) findViewById(R.id.showconstanttbt_Root)); + + final CheckBox useNavigationText1 = (CheckBox) layout.findViewById(R.id.showconstanttbt_useNavigationText1); + final EditText txtNavigationText1 = (EditText) layout.findViewById(R.id.showconstanttbt_txtNavigationText1); + final CheckBox useNavigationText2 = (CheckBox) layout.findViewById(R.id.showconstanttbt_useNavigationText2); + final EditText txtNavigationText2 = (EditText) layout.findViewById(R.id.showconstanttbt_txtNavigationText2); + final CheckBox useETA = (CheckBox) layout.findViewById(R.id.showconstanttbt_useETA); + final EditText txtEta = (EditText) layout.findViewById(R.id.showconstanttbt_txtEta); + final CheckBox useTimeToDestination = (CheckBox) layout.findViewById(R.id.showconstanttbt_useTimeToDestination); + final EditText txtTimeToDestination = (EditText) layout.findViewById(R.id.showconstanttbt_txtTimeToDestination); + final CheckBox useTotalDistance = (CheckBox) layout.findViewById(R.id.showconstanttbt_useTotalDistance); + final EditText txtTotalDistance = (EditText) layout.findViewById(R.id.showconstanttbt_txtTotalDistance); + final CheckBox chkUseTurnIcon = (CheckBox) layout.findViewById(R.id.showconstanttbt_turnIconCheck); + final Spinner spnTurnIconType = (Spinner) layout.findViewById(R.id.showconstanttbt_turnIconType); + final EditText txtTurnIconValue = (EditText) layout.findViewById(R.id.showconstanttbt_turnIconValue); + final CheckBox chkUseNextTurnIcon = (CheckBox) layout.findViewById(R.id.showconstanttbt_nextTurnIconCheck); + final Spinner spnNextTurnIconType = (Spinner) layout.findViewById(R.id.showconstanttbt_nextTurnIconType); + final EditText txtNextTurnIconValue = (EditText) layout.findViewById(R.id.showconstanttbt_nextTurnIconValue); + final CheckBox useDistanceToManeuver = (CheckBox) layout.findViewById(R.id.showconstanttbt_useDistanceToManeuver); + final EditText txtDistanceToManeuver = (EditText) layout.findViewById(R.id.showconstanttbt_txtDistanceToManeuver); + final CheckBox useDistanceToManeuverScale = (CheckBox) layout.findViewById(R.id.showconstanttbt_useDistanceToManeuverScale); + final EditText txtDistanceToManeuverScale = (EditText) layout.findViewById(R.id.showconstanttbt_txtDistanceToManeuverScale); + final CheckBox useManeuverComplete = (CheckBox) layout.findViewById(R.id.showconstanttbt_useManeuverComplete); + final CheckBox chkManeuverComplete = (CheckBox) layout.findViewById(R.id.showconstanttbt_chkManeuverComplete); + final CheckBox useSoftButtons = (CheckBox) layout.findViewById(R.id.showconstanttbt_useSoftButtons); + + spnTurnIconType.setAdapter(imageTypeAdapter); + spnTurnIconType.setSelection(imageTypeAdapter.getPosition(ImageType.DYNAMIC)); + + spnNextTurnIconType.setAdapter(imageTypeAdapter); + spnNextTurnIconType.setSelection(imageTypeAdapter.getPosition(ImageType.DYNAMIC)); + + SoftButton sb1 = new SoftButton(); + sb1.setSoftButtonID(SyncProxyTester.getNewSoftButtonId()); + sb1.setText("Reply"); + sb1.setType(SoftButtonType.SBT_TEXT); + sb1.setIsHighlighted(false); + sb1.setSystemAction(SystemAction.STEAL_FOCUS); + SoftButton sb2 = new SoftButton(); + sb2.setSoftButtonID(SyncProxyTester.getNewSoftButtonId()); + sb2.setText("Close"); + sb2.setType(SoftButtonType.SBT_TEXT); + sb2.setIsHighlighted(false); + sb2.setSystemAction(SystemAction.DEFAULT_ACTION); + currentSoftButtons = new Vector<SoftButton>(); + currentSoftButtons.add(sb1); + currentSoftButtons.add(sb2); + + Button btnSoftButtons = (Button) layout.findViewById(R.id.showconstanttbt_btnSoftButtons); + btnSoftButtons.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + IntentHelper.addObjectForKey(currentSoftButtons, + Const.INTENTHELPER_KEY_OBJECTSLIST); + Intent intent = new Intent(mContext, SoftButtonsListActivity.class); + intent.putExtra(Const.INTENT_KEY_OBJECTS_MAXNUMBER, + SHOWCONSTANTTBT_MAXSOFTBUTTONS); + startActivityForResult(intent, REQUEST_LIST_SOFTBUTTONS); + } + }); + + AlertDialog.Builder builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + try { + ShowConstantTBT msg = new ShowConstantTBT(); + + if (useNavigationText1.isChecked()) { + msg.setNavigationText1(txtNavigationText1.getText().toString()); + } + if (useNavigationText2.isChecked()) { + msg.setNavigationText2(txtNavigationText2.getText().toString()); + } + if (useETA.isChecked()) { + msg.setEta(txtEta.getText().toString()); + } + if (useTimeToDestination.isChecked()) { + msg.setTimeToDestination(txtTimeToDestination.getText().toString()); + } + if (useTotalDistance.isChecked()) { + msg.setTotalDistance(txtTotalDistance.getText().toString()); + } + + if (chkUseTurnIcon.isChecked()) { + Image image = new Image(); + image.setImageType(imageTypeAdapter.getItem( + spnTurnIconType.getSelectedItemPosition())); + image.setValue(txtTurnIconValue.getText().toString()); + msg.setTurnIcon(image); + } + + if (chkUseNextTurnIcon.isChecked()) { + Image image = new Image(); + image.setImageType(imageTypeAdapter.getItem( + spnNextTurnIconType.getSelectedItemPosition())); + image.setValue(txtNextTurnIconValue.getText().toString()); + msg.setNextTurnIcon(image); + } + + if (useDistanceToManeuver.isChecked()) { + msg.setDistanceToManeuver((float) Integer.parseInt(txtDistanceToManeuver.getText().toString())); + } + if (useDistanceToManeuverScale.isChecked()) { + msg.setDistanceToManeuverScale((float) Integer.parseInt(txtDistanceToManeuverScale.getText().toString())); + } + if (useManeuverComplete.isChecked()) { + msg.setManeuverComplete(chkManeuverComplete.isChecked()); + } + msg.setCorrelationID(getCorrelationid()); + if (useSoftButtons.isChecked()) { + if (currentSoftButtons != null) { + msg.setSoftButtons(currentSoftButtons); + } else { + msg.setSoftButtons(new Vector<SoftButton>()); + } + } + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } catch (NumberFormatException e) { + SafeToast.showToastAnyThread("Couldn't parse number"); + } + currentSoftButtons = null; + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + currentSoftButtons = null; + dialog.cancel(); + } + }); + builder.setView(layout); + builder.show(); + } + + /** + * Opens the dialog for CreateInteractionChoiceSet message and sends it. + */ + private void sendCreateInteractionChoiceSet() { + Choice choice1 = new Choice(); + choice1.setChoiceID(getNewChoiceId()); + choice1.setMenuName("super"); + Vector<String> vrCommands = new Vector<String>(); + vrCommands.add("super"); + vrCommands.add("best"); + choice1.setVrCommands(vrCommands); + Image image = new Image(); + image.setImageType(ImageType.DYNAMIC); + image.setValue("turn_left.png"); + choice1.setImage(image); + choice1.setSecondaryText("42"); + choice1.setTertiaryText("The Cat"); + + Choice choice2 = new Choice(); + choice2.setChoiceID(getNewChoiceId()); + choice2.setMenuName("awesome"); + vrCommands = new Vector<String>(); + vrCommands.add("magnificent"); + vrCommands.add("incredible"); + choice2.setVrCommands(vrCommands); + image = new Image(); + image.setImageType(ImageType.DYNAMIC); + image.setValue("action.png"); + choice2.setImage(image); + choice2.setTertiaryText("Schrödinger's cat"); + + Vector<Choice> choices = new Vector<Choice>(); + choices.add(choice1); + choices.add(choice2); + + IntentHelper.addObjectForKey(choices, + Const.INTENTHELPER_KEY_OBJECTSLIST); + Intent intent = new Intent(adapter.getContext(), + ChoiceListActivity.class); + intent.putExtra(Const.INTENT_KEY_OBJECTS_MAXNUMBER, + CREATECHOICESET_MAXCHOICES); + startActivityForResult(intent, REQUEST_LIST_CHOICES); + } + + /** + * Opens the dialog for Show message and sends it. + */ + private void sendShow() { + final Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.show, null); + + final CheckBox mainField1Check = (CheckBox) layout.findViewById(R.id.show_mainField1Check); + final EditText mainField1 = (EditText) layout.findViewById(R.id.show_mainField1); + final CheckBox mainField2Check = (CheckBox) layout.findViewById(R.id.show_mainField2Check); + final EditText mainField2 = (EditText) layout.findViewById(R.id.show_mainField2); + final CheckBox mainField3Check = (CheckBox) layout.findViewById(R.id.show_mainField3Check); + final EditText mainField3 = (EditText) layout.findViewById(R.id.show_mainField3); + final CheckBox mainField4Check = (CheckBox) layout.findViewById(R.id.show_mainField4Check); + final EditText mainField4 = (EditText) layout.findViewById(R.id.show_mainField4); + final CheckBox textAlignmentCheck = (CheckBox) layout.findViewById(R.id.show_textAlignmentCheck); + final Spinner textAlignmentSpinner = (Spinner) layout.findViewById(R.id.show_textAlignmentSpinner); + final CheckBox statusBarCheck = (CheckBox) layout.findViewById(R.id.show_statusBarCheck); + final EditText statusBar = (EditText) layout.findViewById(R.id.show_statusBar); + final CheckBox mediaClockCheck = (CheckBox) layout.findViewById(R.id.show_mediaClockCheck); + final EditText mediaClock = (EditText) layout.findViewById(R.id.show_mediaClock); + final CheckBox mediaTrackCheck = (CheckBox) layout.findViewById(R.id.show_mediaTrackCheck); + final EditText mediaTrack = (EditText) layout.findViewById(R.id.show_mediaTrack); + final CheckBox graphicCheck = (CheckBox) layout.findViewById(R.id.show_graphicCheck); + final Spinner graphicType = (Spinner) layout.findViewById(R.id.show_graphicType); + final EditText graphic = (EditText) layout.findViewById(R.id.show_graphic); + final CheckBox secondaryGraphicCheck = (CheckBox) layout.findViewById(R.id.show_secondaryGraphicCheck); + final Spinner secondaryGraphicType = (Spinner) layout.findViewById(R.id.show_secondaryGraphicType); + final EditText secondaryGraphic = (EditText) layout.findViewById(R.id.show_secondaryGraphic); + chkIncludeSoftButtons = (CheckBox) layout.findViewById(R.id.show_chkIncludeSBs); + final Button softButtons = (Button) layout.findViewById(R.id.show_btnSoftButtons); + final CheckBox customPresetsCheck = (CheckBox) layout.findViewById(R.id.show_customPresetsCheck); + final EditText customPresets = (EditText) layout.findViewById(R.id.show_customPresets); + + final ArrayAdapter<TextAlignment> textAlignmentAdapter = new ArrayAdapter<TextAlignment>( + mContext, android.R.layout.simple_spinner_item, TextAlignment.values()); + textAlignmentAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + textAlignmentSpinner.setAdapter(textAlignmentAdapter); + textAlignmentSpinner.setSelection(textAlignmentAdapter.getPosition(TextAlignment.CENTERED)); + + final boolean isMedia = getIsMedia(); + + if (!isMedia) { + int visibility = View.GONE; + mediaClock.setVisibility(visibility); + mediaTrack.setVisibility(visibility); + mediaTrackCheck.setVisibility(visibility); + mediaClockCheck.setVisibility(visibility); + } + + graphicType.setAdapter(imageTypeAdapter); + graphicType.setSelection(imageTypeAdapter.getPosition(ImageType.DYNAMIC)); + secondaryGraphicType.setAdapter(imageTypeAdapter); + secondaryGraphicType.setSelection(imageTypeAdapter.getPosition(ImageType.DYNAMIC)); + + SoftButton sb1 = new SoftButton(); + sb1.setSoftButtonID(SyncProxyTester.getNewSoftButtonId()); + sb1.setText("KeepContext"); + sb1.setType(SoftButtonType.SBT_TEXT); + sb1.setIsHighlighted(false); + sb1.setSystemAction(SystemAction.KEEP_CONTEXT); + SoftButton sb2 = new SoftButton(); + sb2.setSoftButtonID(SyncProxyTester.getNewSoftButtonId()); + sb2.setText("StealFocus"); + sb2.setType(SoftButtonType.SBT_TEXT); + sb2.setIsHighlighted(false); + sb2.setSystemAction(SystemAction.STEAL_FOCUS); + SoftButton sb3 = new SoftButton(); + sb3.setSoftButtonID(SyncProxyTester.getNewSoftButtonId()); + sb3.setText("Default"); + sb3.setType(SoftButtonType.SBT_TEXT); + sb3.setIsHighlighted(false); + sb3.setSystemAction(SystemAction.DEFAULT_ACTION); + currentSoftButtons = new Vector<SoftButton>(); + currentSoftButtons.add(sb1); + currentSoftButtons.add(sb2); + currentSoftButtons.add(sb3); + + Button btnSoftButtons = (Button) layout.findViewById(R.id.show_btnSoftButtons); + btnSoftButtons.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + IntentHelper + .addObjectForKey(currentSoftButtons, Const.INTENTHELPER_KEY_OBJECTSLIST); + Intent intent = new Intent(mContext, SoftButtonsListActivity.class); + intent.putExtra(Const.INTENT_KEY_OBJECTS_MAXNUMBER, SHOW_MAXSOFTBUTTONS); + startActivityForResult(intent, REQUEST_LIST_SOFTBUTTONS); + } + }); + + AlertDialog.Builder builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + Show msg = new Show(); + msg.setCorrelationID(getCorrelationid()); + + if (mainField1Check.isChecked()) { + msg.setMainField1(mainField1.getText().toString()); + } + if (mainField2Check.isChecked()) { + msg.setMainField2(mainField2.getText().toString()); + } + if (mainField3Check.isChecked()) { + msg.setMainField3(mainField3.getText().toString()); + } + if (mainField4Check.isChecked()) { + msg.setMainField4(mainField4.getText().toString()); + } + if (textAlignmentCheck.isChecked()) { + msg.setAlignment(textAlignmentAdapter.getItem(textAlignmentSpinner.getSelectedItemPosition())); + } + if (statusBarCheck.isChecked()) { + msg.setStatusBar(statusBar.getText().toString()); + } + if (isMedia) { + if (mediaClockCheck.isChecked()) { + msg.setMediaClock(mediaClock.getText().toString()); + } + if (mediaTrackCheck.isChecked()) { + msg.setMediaTrack(mediaTrack.getText().toString()); + } + } + if (graphicCheck.isChecked()) { + Image image = new Image(); + image.setImageType((ImageType) graphicType.getSelectedItem()); + image.setValue(graphic.getText().toString()); + msg.setGraphic(image); + } + if (secondaryGraphicCheck.isChecked()) { + Image image = new Image(); + image.setImageType((ImageType) secondaryGraphicType.getSelectedItem()); + image.setValue(secondaryGraphic.getText().toString()); + msg.setSecondaryGraphic(image); + } + if (chkIncludeSoftButtons.isChecked() && + (currentSoftButtons != null) && + (currentSoftButtons.size() > 0)) { + msg.setSoftButtons(currentSoftButtons); + } + currentSoftButtons = null; + chkIncludeSoftButtons = null; + if (customPresetsCheck.isChecked()) { + String[] customPresetsList = customPresets.getText(). + toString().split(JOIN_STRING); + msg.setCustomPresets(new Vector<String>(Arrays. + asList(customPresetsList))); + } + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + currentSoftButtons = null; + chkIncludeSoftButtons = null; + dialog.cancel(); + } + }); + builder.setView(layout); + builder.show(); + } + + /** + * Opens the dialog for PerformInteraction message and sends it. + */ + private void sendPerformInteraction() { + final Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + + View layout = inflater.inflate(R.layout.performinteraction, + (ViewGroup) findViewById(R.id.performinteraction_Root)); + + final EditText initialText = (EditText) layout.findViewById(R.id.performinteraction_initialText); + final EditText initialPrompt = (EditText) layout.findViewById(R.id.performinteraction_initialPrompt); + final Spinner interactionModeSpinner = (Spinner) layout.findViewById(R.id.performinteraction_interactionModeSpinner); + final Button choiceSetIDs = (Button) layout.findViewById(R.id.performinteraction_choiceSetIDs); + final CheckBox helpPromptCheck = (CheckBox) layout.findViewById(R.id.performinteraction_helpPromptCheck); + final EditText helpPrompt = (EditText) layout.findViewById(R.id.performinteraction_helpPrompt); + final CheckBox timeoutPromptCheck = (CheckBox) layout.findViewById(R.id.performinteraction_timeoutPromptCheck); + final EditText timeoutPrompt = (EditText) layout.findViewById(R.id.performinteraction_timeoutPrompt); + final CheckBox timeoutCheck = (CheckBox) layout.findViewById(R.id.performinteraction_timeoutCheck); + final EditText timeout = (EditText) layout.findViewById(R.id.performinteraction_timeout); + final CheckBox vrHelpItemCheck = (CheckBox) layout.findViewById(R.id.performinteraction_vrHelpItemCheck); + final EditText vrHelpItemPos = (EditText) layout.findViewById(R.id.performinteraction_vrHelpItemPos); + final EditText vrHelpItemText = (EditText) layout.findViewById(R.id.performinteraction_vrHelpItemText); + final EditText vrHelpItemImage = (EditText) layout.findViewById(R.id.performinteraction_vrHelpItemImage); + final CheckBox interactionLayoutCheck = + (CheckBox) layout.findViewById( + R.id.performinteraction_interactionLayoutCheck); + final Spinner interactionLayoutSpinner = + (Spinner) layout.findViewById( + R.id.performinteraction_interactionLayoutSpinner); + + final ArrayAdapter<InteractionMode> interactionModeAdapter = new ArrayAdapter<InteractionMode>( + mContext, android.R.layout.simple_spinner_item, InteractionMode.values()); + interactionModeAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + interactionModeSpinner.setAdapter(interactionModeAdapter); + interactionModeSpinner.setSelection(interactionModeAdapter.getPosition(InteractionMode.BOTH)); + + final ArrayAdapter<LayoutMode> + interactionLayoutAdapter = + new ArrayAdapter<LayoutMode>(mContext, + android.R.layout.simple_spinner_item, + LayoutMode.values()); + interactionLayoutAdapter.setDropDownViewResource( + android.R.layout.simple_spinner_dropdown_item); + interactionLayoutSpinner + .setAdapter(interactionLayoutAdapter); + + final String[] choiceSetIDStrings = new String[mChoiceSetAdapter.getCount()]; + final boolean[] choiceSetIDSelections = new boolean[choiceSetIDStrings.length]; + + for (int i = 0; i < mChoiceSetAdapter.getCount(); ++i) { + choiceSetIDStrings[i] = mChoiceSetAdapter.getItem(i).toString(); + } + + choiceSetIDs.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + new AlertDialog.Builder(mContext). + setMultiChoiceItems(choiceSetIDStrings, choiceSetIDSelections, new OnMultiChoiceClickListener() { + @Override + public void onClick(DialogInterface dialog, int which, boolean isChecked) { + } + }). + setPositiveButton("OK", new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, int which) { + dialog.dismiss(); + } + }). + show(); + } + }); + + AlertDialog.Builder builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, int which) { + // fail if no interaction choice set selected + Vector<Integer> choiceSetIDs = new Vector<Integer>(); + for (int i = 0; i < choiceSetIDSelections.length; ++i) { + if (choiceSetIDSelections[i]) { + choiceSetIDs.add(mChoiceSetAdapter.getItem(i)); + } + } + sendPerformInteractionRequest(choiceSetIDs); + } + + private void sendPerformInteractionRequest(Vector<Integer> choiceSetIDs) { + + PerformInteraction msg = new PerformInteraction(); + msg.setCorrelationID(getCorrelationid()); + msg.setInitialText(initialText.getText().toString()); + msg.setInitialPrompt(ttsChunksFromString(initialPrompt.getText().toString())); + msg.setInteractionMode( + interactionModeAdapter.getItem( + interactionModeSpinner + .getSelectedItemPosition())); + msg.setInteractionChoiceSetIDList(choiceSetIDs); + + if (helpPromptCheck.isChecked()) { + msg.setHelpPrompt(ttsChunksFromString(helpPrompt.getText().toString())); + } + + if (timeoutPromptCheck.isChecked()) { + msg.setTimeoutPrompt(ttsChunksFromString(timeoutPrompt.getText().toString())); + } + + if (timeoutCheck.isChecked()) { + try { + msg.setTimeout(Integer.parseInt(timeout.getText().toString())); + } catch (NumberFormatException e) { + // set default timeout + msg.setTimeout(10000); + } + } + + if (vrHelpItemCheck.isChecked()) { + Vector<VrHelpItem> vrHelpItems = new Vector<VrHelpItem>(); + + String[] itemTextArray = vrHelpItemText.getText().toString().split(JOIN_STRING); + String[] itemPosArray = vrHelpItemPos.getText().toString().split(JOIN_STRING); + String[] itemImageArray = vrHelpItemImage.getText().toString() + .split(JOIN_STRING); + int itemsCount = Math.min(itemTextArray.length, + Math.min(itemPosArray.length, itemImageArray.length)); + + for (int i = 0; i < itemsCount; ++i) { + VrHelpItem item = new VrHelpItem(); + item.setText(itemTextArray[i]); + + try { + item.setPosition(Integer.parseInt(itemPosArray[i])); + } catch (NumberFormatException e) { + // set default position + item.setPosition(1); + } + + Image image = new Image(); + image.setValue(itemImageArray[i]); + image.setImageType(ImageType.DYNAMIC); + item.setImage(image); + + vrHelpItems.add(item); + } + + msg.setVrHelp(vrHelpItems); + } + + if (interactionLayoutCheck.isChecked()) { + msg.setInteractionLayout(interactionLayoutAdapter + .getItem(interactionLayoutSpinner + .getSelectedItemPosition())); + } + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, int which) { + dialog.cancel(); + } + }); + + builder.setView(layout); + builder.show(); + } + + private void sendUpdateTurnList() { + AlertDialog.Builder builder; + + final Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.updateturnlist, null); + final EditText txtTurnList = (EditText) layout.findViewById(R.id.updateturnlist_txtTurnList); + final EditText txtIconList = (EditText) layout.findViewById(R.id.updateturnlist_txtIconList); + final CheckBox useTurnList = (CheckBox) layout.findViewById(R.id.updateturnlist_useTurnList); + final CheckBox useIconList = (CheckBox) layout.findViewById(R.id.updateturnlist_useIconList); + final CheckBox useSoftButtons = (CheckBox) layout.findViewById(R.id.updateturnlist_chkIncludeSBs); + + SoftButton sb1 = new SoftButton(); + sb1.setSoftButtonID(SyncProxyTester.getNewSoftButtonId()); + sb1.setText("Close"); + sb1.setType(SoftButtonType.SBT_TEXT); + sb1.setIsHighlighted(false); + sb1.setSystemAction(SystemAction.DEFAULT_ACTION); + currentSoftButtons = new Vector<SoftButton>(); + currentSoftButtons.add(sb1); + + Button btnSoftButtons = (Button) layout.findViewById(R.id.updateturnlist_btnSoftButtons); + btnSoftButtons.setOnClickListener(new OnClickListener() { + @Override + public void onClick(View v) { + IntentHelper.addObjectForKey(currentSoftButtons, + Const.INTENTHELPER_KEY_OBJECTSLIST); + Intent intent = new Intent(mContext, SoftButtonsListActivity.class); + intent.putExtra(Const.INTENT_KEY_OBJECTS_MAXNUMBER, + UPDATETURNLIST_MAXSOFTBUTTONS); + startActivityForResult(intent, REQUEST_LIST_SOFTBUTTONS); + } + }); + + builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + /* + * the number of items to send is determined as max of turn items + * and icon items. only when the both fields are empty, we + * don't send anything. + */ + boolean turnListEnabled = useTurnList.isChecked(); + boolean iconListEnabled = useIconList.isChecked(); + String turnListString = txtTurnList.getText().toString(); + String iconListString = txtIconList.getText().toString(); + if ((turnListString.length() > 0) || (iconListString.length() > 0)) { + Vector<Turn> tarray = new Vector<Turn>(); + + String[] iconNames = iconListString.split(JOIN_STRING); + String[] turnNames = turnListString.split(JOIN_STRING); + int turnCount = Math.max(iconNames.length, turnNames.length); + + for (int i = 0; i < turnCount; ++i) { + Turn t = new Turn(); + if (turnListEnabled) { + t.setNavigationText((i < turnNames.length) ? turnNames[i] : ""); + } + + if (iconListEnabled) { + Image ti = new Image(); + ti.setValue((i < iconNames.length) ? iconNames[i] : ""); + ti.setImageType(ImageType.DYNAMIC); + t.setTurnIcon(ti); + } + tarray.add(t); + } + UpdateTurnList msg = new UpdateTurnList(); + msg.setCorrelationID(getCorrelationid()); + msg.setTurnList(tarray); + if (useSoftButtons.isChecked()) { + if (currentSoftButtons != null) { + msg.setSoftButtons( + currentSoftButtons); + } else { + msg.setSoftButtons( + new Vector<SoftButton>()); + } + } + currentSoftButtons = null; + + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } else { + Toast.makeText(mContext, "Both fields are empty, nothing to send", + Toast.LENGTH_LONG).show(); + } + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + currentSoftButtons = null; + dialog.cancel(); + } + }); + builder.setView(layout); + builder.show(); + } + + private void updateDynamicFooter(EditText txtNumTicks, + EditText txtSliderFooter, String joinString) { + // set numTicks comma-separated strings + int numTicks = 0; + try { + numTicks = Integer.parseInt(txtNumTicks.getText().toString()); + } catch (NumberFormatException e) { + // do nothing, leave 0 + } + if (numTicks > 0) { + StringBuilder b = new StringBuilder(); + for (int i = 0; i < numTicks; ++i) { + b.append(joinString).append(i + 1); + } + txtSliderFooter.setText(b.toString().substring(joinString.length())); + } else { + txtSliderFooter.setText(""); + } + } + + private void sendSlider() { + AlertDialog.Builder builder; + + final Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.slider, null); + final EditText txtNumTicks = (EditText) layout.findViewById(R.id.txtNumTicks); + final EditText txtPosititon = (EditText) layout.findViewById(R.id.txtPosition); + final EditText txtSliderHeader = (EditText) layout.findViewById(R.id.txtSliderHeader); + final EditText txtSliderFooter = (EditText) layout.findViewById(R.id.txtSliderFooter); + final CheckBox useTimeout = (CheckBox) layout.findViewById(R.id.slider_useTimeout); + final EditText txtTimeout = (EditText) layout.findViewById(R.id.txtTimeout); + + final CheckBox chkDynamicFooter = (CheckBox) layout.findViewById(R.id.slider_chkDynamicFooter); + chkDynamicFooter.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { + if (!isChecked) { + // set default static text + txtSliderFooter.setText(R.string.slider_footer); + } else { + updateDynamicFooter(txtNumTicks, txtSliderFooter, JOIN_STRING); + } + } + }); + + /** + * Process a possibility to exclude Footer from Slider request + */ + final boolean[] isUseFooterInSlider = {true}; + final CheckBox useFooterInSliderCheckBox = (CheckBox) layout.findViewById(R.id.use_footer_in_slider_checkbox); + isUseFooterInSlider[0] = useFooterInSliderCheckBox.isChecked(); + useFooterInSliderCheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() { + @Override + public void onCheckedChanged(CompoundButton compoundButton, boolean b) { + isUseFooterInSlider[0] = b; + chkDynamicFooter.setEnabled(b); + txtSliderFooter.setEnabled(b); + } + }); + + builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + try { + Slider msg = new Slider(); + if (useTimeout.isChecked()) { + msg.setTimeout(Integer.parseInt(txtTimeout.getText().toString())); + } + msg.setNumTicks(Integer.parseInt(txtNumTicks.getText().toString())); + msg.setSliderHeader(txtSliderHeader.getText().toString()); + + /** + * Do not set Footer + */ + if (isUseFooterInSlider[0]) { + Vector<String> footerElements; + String footer = txtSliderFooter.getText().toString(); + if (chkDynamicFooter.isChecked()) { + footerElements = new Vector<String>(Arrays.asList(footer.split(JOIN_STRING))); + } else { + footerElements = new Vector<String>(); + footerElements.add(footer); + } + msg.setSliderFooter(footerElements); + } + + msg.setPosition(Integer.parseInt(txtPosititon.getText().toString())); + msg.setCorrelationID(getCorrelationid()); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } catch (NumberFormatException e) { + SafeToast.showToastAnyThread("Couldn't parse number"); + } + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + builder.setView(layout); + builder.show(); + } + + private void sendVehicleDataSubscriptions() { + DialogFragment subscriptionsVehicleDataDialog = + SubscriptionsVehicleDataDialog.newInstance(); + subscriptionsVehicleDataDialog.show(getFragmentManager(), + SUBSCRIPTION_VEHICLE_DATA_DIALOG_TAG); + } + + private void sendSetGlobalProperties() { + DialogFragment setGlobalPropertiesDialog = + SetGlobalPropertiesDialog.newInstance(); + setGlobalPropertiesDialog.show(getFragmentManager(), + SET_GLOBAL_PROPERTIES_DIALOG_TAG); + } + + private void sendResetGlobalProperties() { + AlertDialog.Builder builder; + + Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.resetglobalproperties, + (ViewGroup) findViewById(R.id.resetglobalproperties_Root)); + + final CheckBox choiceHelpPrompt = (CheckBox) layout.findViewById(R.id.resetglobalproperties_choiceHelpPrompt); + final CheckBox choiceTimeoutPrompt = (CheckBox) layout.findViewById(R.id.resetglobalproperties_choiceTimeoutPrompt); + final CheckBox choiceVRHelpTitle = (CheckBox) layout.findViewById(R.id.resetglobalproperties_choiceVRHelpTitle); + final CheckBox choiceVRHelpItem = (CheckBox) layout.findViewById(R.id.resetglobalproperties_choiceVRHelpItems); + final CheckBox choiceKeyboardProperties = (CheckBox) layout.findViewById(R.id.resetglobalproperties_choiceKeyboardProperties); + final CheckBox choiceMenuIcon = (CheckBox) layout.findViewById(R.id.resetglobalproperties_choiceMenuIcon); + final CheckBox choiceMenuName = (CheckBox) layout.findViewById(R.id.resetglobalproperties_choiceMenuName); + + builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + ResetGlobalProperties msg = new ResetGlobalProperties(); + Vector<GlobalProperty> properties = new Vector<GlobalProperty>(); + + if (choiceHelpPrompt.isChecked()) { + properties.add(GlobalProperty.HELPPROMPT); + } + + if (choiceTimeoutPrompt.isChecked()) { + properties.add(GlobalProperty.TIMEOUTPROMPT); + } + + if (choiceVRHelpTitle.isChecked()) { + properties.add(GlobalProperty.VRHELPTITLE); + } + + if (choiceVRHelpItem.isChecked()) { + properties.add(GlobalProperty.VRHELPITEMS); + } + + if (choiceMenuIcon.isChecked()) { + properties.add(GlobalProperty.MENUICON); + } + + if (choiceMenuName.isChecked()) { + properties.add(GlobalProperty.MENUNAME); + } + + if (choiceKeyboardProperties.isChecked()) { + properties.add(GlobalProperty.KEYBOARDPROPERTIES); + } + + if (!properties.isEmpty()) { + msg.setProperties(properties); + msg.setCorrelationID(getCorrelationid()); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } else { + Toast.makeText(getApplicationContext(), "No items selected", Toast.LENGTH_LONG).show(); + } + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + builder.setView(layout); + builder.create().show(); + } + + + /** + * Opens the dialog for SetDisplayLayout message and sends it. + */ + private void sendSetDisplayLayout() { + Context mContext = adapter.getContext(); + LayoutInflater inflater = (LayoutInflater) mContext + .getSystemService(LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.setdisplaylayout, + (ViewGroup) findViewById(R.id.setdisplaylayout_itemRoot)); + + final EditText editDisplayLayout = (EditText) layout.findViewById(R.id.setdisplaylayout_displayLayout); + + AlertDialog.Builder builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + SetDisplayLayout msg = new SetDisplayLayout(); + msg.setCorrelationID(getCorrelationid()); + msg.setDisplayLayout(editDisplayLayout.getText().toString()); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } + }); + builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + builder.setView(layout); + builder.show(); + } + + /** + * Sends a GenericRequest message. + */ + private void sendGenericRequest() { + GenericRequest msg = new GenericRequest(); + msg.setCorrelationID(getCorrelationid()); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } + }) + .setNegativeButton("Close", null) + .show(); + } else if (v == findViewById(R.id.btnPlayPause)) { + mBoundProxyService.playPauseAnnoyingRepetitiveAudio(); + } + } + + private void sendSetMediaClockTimer() { + AlertDialog.Builder builder; + + Context mContext = this; + LayoutInflater inflater = (LayoutInflater) mContext.getSystemService( + LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.setmediaclock, null); + final EditText txtStartHours = (EditText) layout.findViewById( + R.id.setmediaclocktimer_startTimeHours); + final EditText txtStartMinutes = (EditText) layout.findViewById( + R.id.setmediaclocktimer_startTimeMinutes); + final EditText txtStartSeconds = (EditText) layout.findViewById( + R.id.setmediaclocktimer_startTimeSeconds); + final EditText txtEndHours = (EditText) layout.findViewById( + R.id.setmediaclocktimer_endTimeHours); + final EditText txtEndMinutes = (EditText) layout.findViewById( + R.id.setmediaclocktimer_endTimeMinutes); + final EditText txtEndSeconds = (EditText) layout.findViewById( + R.id.setmediaclocktimer_endTimeSeconds); + final Spinner spnUpdateMode = (Spinner) layout.findViewById( + R.id.setmediaclocktimer_spnUpdateMode); + + ArrayAdapter<UpdateMode> spinnerAdapter = + new ArrayAdapter<UpdateMode>(mContext, + android.R.layout.simple_spinner_item, + UpdateMode.values()); + spinnerAdapter.setDropDownViewResource( + android.R.layout.simple_spinner_dropdown_item); + spnUpdateMode.setAdapter(spinnerAdapter); + + builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + SetMediaClockTimer msg = new SetMediaClockTimer(); + msg.setCorrelationID(getCorrelationid()); + UpdateMode updateMode = + (UpdateMode) spnUpdateMode.getSelectedItem(); + msg.setUpdateMode(updateMode); + + try { + Integer hours = Integer.parseInt( + txtStartHours.getText().toString()); + Integer minutes = Integer.parseInt( + txtStartMinutes.getText().toString()); + Integer seconds = Integer.parseInt( + txtStartSeconds.getText().toString()); + StartTime startTime = new StartTime(); + startTime.setHours(hours); + startTime.setMinutes(minutes); + startTime.setSeconds(seconds); + msg.setStartTime(startTime); + } catch (NumberFormatException e) { + // skip setting start time if parsing failed + } + + try { + Integer hours = + Integer.parseInt(txtEndHours.getText().toString()); + Integer minutes = Integer.parseInt( + txtEndMinutes.getText().toString()); + Integer seconds = Integer.parseInt( + txtEndSeconds.getText().toString()); + StartTime endTime = new StartTime(); + endTime.setHours(hours); + endTime.setMinutes(minutes); + endTime.setSeconds(seconds); + msg.setEndTime(endTime); + } catch (NumberFormatException e) { + // skip setting start time if parsing failed + } + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } + }); + builder.setNegativeButton("Cancel", + new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + builder.setView(layout); + builder.show(); + } + + private void initProxyService() { + mBoundProxyService.setLogAdapter(mLogAdapter); + mBoundProxyService.setProxyServiceEvent(this); + } + + private void getProxyService() { + mBoundProxyService = null; + mBoundProxyService = MainApp.getInstance().getBoundProxyService(); + } + + private void sendDiagnosticMessage() { + final Context mContext = this; + LayoutInflater inflater = (LayoutInflater) mContext.getSystemService( + LAYOUT_INFLATER_SERVICE); + View layout = inflater.inflate(R.layout.diagnosticmessage, null); + final EditText txtTargetID = (EditText) layout.findViewById( + R.id.diagnosticmessage_txtTargetID); + final EditText txtMessageLength = (EditText) layout.findViewById( + R.id.diagnosticmessage_txtMessageLength); + final EditText txtMessageData = (EditText) layout.findViewById( + R.id.diagnosticmessage_txtMessageData); + final CheckBox useTargetID = (CheckBox) layout.findViewById( + R.id.diagnosticmessage_useTargetID); + final CheckBox useMessageLength = (CheckBox) layout.findViewById( + R.id.diagnosticmessage_useMessageLength); + final CheckBox useMessageData = (CheckBox) layout.findViewById( + R.id.diagnosticmessage_useMessageData); + + AlertDialog.Builder builder = new AlertDialog.Builder(mContext); + builder.setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + try { + DiagnosticMessage msg = new DiagnosticMessage(); + msg.setCorrelationID(getCorrelationid()); + + if (useTargetID.isChecked()) { + msg.setTargetID(Integer.valueOf( + txtTargetID.getText().toString())); + } + + if (useMessageLength.isChecked()) { + msg.setMessageLength(Integer.valueOf( + txtMessageLength.getText().toString())); + } + + if (useMessageData.isChecked()) { + final String[] msgData = txtMessageData.getText() + .toString() + .split(JOIN_STRING); + final Vector<Integer> data = new Vector<Integer>(); + for (String s : msgData) { + data.add(Integer.valueOf(s)); + } + msg.setMessageData(data); + } + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } catch (NumberFormatException e) { + SafeToast.showToastAnyThread("Couldn't parse number"); + } + } + }); + builder.setNegativeButton("Cancel", + new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + dialog.cancel(); + } + }); + builder.setView(layout); + builder.show(); + } + + /** + * Sends RegisterAppInterface message. + */ + private void sendRegisterAppInterface() { + DialogFragment registerAppInterfaceDialog = RegisterAppInterfaceDialog.newInstance(); + registerAppInterfaceDialog.show(getFragmentManager(), REGISTER_APP_INTERFACE_DIALOG_TAG); + } + + /** + * Splits the string with a comma and returns a vector of TTSChunks. + */ + public Vector<TTSChunk> ttsChunksFromString(String string) { + Vector<TTSChunk> chunks = new Vector<TTSChunk>(); + for (String stringChunk : string.split(JOIN_STRING)) { + TTSChunk chunk = TTSChunkFactory.createChunk(SpeechCapabilities.TEXT, stringChunk); + chunks.add(chunk); + } + return chunks; + } + + /** + * Calls the setter with setterName on the msg. + */ + public void setVehicleDataParam(RPCRequest msg, Class msgClass, String setterName) { + try { + Method setter = msgClass.getMethod(setterName, Boolean.class); + setter.invoke(msg, true); + } catch (NoSuchMethodException e) { + Log.e(LOG_TAG, "Can't set vehicle data", e); + } catch (IllegalAccessException e) { + Log.e(LOG_TAG, "Can't set vehicle data", e); + } catch (InvocationTargetException e) { + Log.e(LOG_TAG, "Can't set vehicle data", e); + } + } + + public void addSubMenuToList(final SyncSubMenu sm) { + runOnUiThread(new Runnable() { + public void run() { + mSubmenuAdapter.add(sm); + } + }); + } + + /** + * This method provides {@link android.widget.ArrayAdapter} to the UI components of the + * DialogFragments + * + * @return {@link android.widget.ArrayAdapter} + */ + public ArrayAdapter<SyncSubMenu> getSubMenuAdapter() { + return mSubmenuAdapter; + } + + /** + * This method provides {@link android.widget.ArrayAdapter} to the UI components of the + * DialogFragments + * + * @return {@link android.widget.ArrayAdapter} + */ + public ArrayAdapter<ImageType> getImageTypeAdapter() { + return imageTypeAdapter; + } + + /** + * This is a callback function for the result of the + * {@link com.ford.syncV4.android.activity.SubscriptionsVehicleDataDialog} + * + * @param unsubscribeVehicleData {@link com.ford.syncV4.proxy.rpc.UnsubscribeVehicleData} + */ + public void onUnsubscribeVehicleDialogResult(UnsubscribeVehicleData unsubscribeVehicleData) { + if (mBoundProxyService != null) { + mBoundProxyService.commandUnsubscribeVehicleInterface(unsubscribeVehicleData); + } + } + + /** + * This is a callback function for the result of the + * {@link com.ford.syncV4.android.activity.SubscriptionsVehicleDataDialog} + * + * @param subscribeVehicleData {@link com.ford.syncV4.proxy.rpc.SubscribeVehicleData} + */ + public void onSubscribeVehicleDialogResult(SubscribeVehicleData subscribeVehicleData) { + if (mBoundProxyService != null) { + mBoundProxyService.commandSubscribeVehicleInterfaceResumable(subscribeVehicleData); + } + } + + /** + * This is a callback function for the result of the + * {@link com.ford.syncV4.android.activity.SetGlobalPropertiesDialog} + * + * @param setGlobalProperties {@link com.ford.syncV4.proxy.rpc.SetGlobalProperties} request + */ + public void onSetGlobalPropertiesDialogResult(SetGlobalProperties setGlobalProperties) { + if (mBoundProxyService != null) { + mBoundProxyService.commandSetGlobalPropertiesResumable(setGlobalProperties); + } + } + + /** + * This is a callback function for the result of the + * {@link com.ford.syncV4.android.activity.AddSubMenuDialog} + * + * @param addSubMenu {@link com.ford.syncV4.android.activity.AddSubMenuDialog} request + * @param syncSubMenu SubMenu structure + */ + public void onAddSubMenuDialogResult(AddSubMenu addSubMenu, SyncSubMenu syncSubMenu) { + if (mBoundProxyService != null) { + mBoundProxyService.commandAddSubMenuResumable(addSubMenu); + } + if (mLatestAddSubmenu != null) { + Log.w(LOG_TAG, "Latest AddSubMenu should be null, but equals to " + mLatestAddSubmenu); + } + mLatestAddSubmenu = syncSubMenu; + } + + /** + * + */ + public void onPolicyFilesSetUpDialogResult_SendUpdate() { + if (mBoundProxyService != null) { + mBoundProxyService.sendPolicyTableUpdate(); + } + } + + /** + * This is a callback function for the result of the + * {@link com.ford.syncV4.android.activity.AddCommandDialog} + * + * @param addCommand {@link com.ford.syncV4.proxy.rpc.AddCommand} + */ + public void onAddCommandDialogResult(AddCommand addCommand) { + if (mBoundProxyService != null) { + mBoundProxyService.commandAddCommandResumable(addCommand); + } + + if (mLatestAddCommand != null) { + Log.w(LOG_TAG, + "Latest addCommand should be null, but it is " + mLatestAddCommand.first + + " / " + mLatestAddCommand.second); + } + Integer parentID = null; + if (addCommand.getMenuParams() != null) { + parentID = addCommand.getMenuParams().getParentID(); + } + mLatestAddCommand = new Pair<Integer, Integer>(addCommand.getCmdID(), parentID); + } + + /** + * This is a callback function for the result of the + * {@link com.ford.syncV4.proxy.rpc.RegisterAppInterface} + * + * @param registerAppInterface {@link com.ford.syncV4.proxy.rpc.RegisterAppInterface} + */ + public void onRegisterAppInterfaceDialogResult(RegisterAppInterface registerAppInterface) { + if (mBoundProxyService != null) { + if (mBoundProxyService.isSyncProxyConnected()) { + mBoundProxyService.syncProxySendRPCRequest(registerAppInterface); + } else { + // This may happen if "UnregisterAppInterface" command has been sent manually + // from the SPT + + Log.w(LOG_TAG, "OnRegisterAppInterfaceDialogResult -> SyncProxy not connected"); + + onSetUpDialogResult(); + } + } else { + Log.w(LOG_TAG, "OnRegisterAppInterfaceDialogResult -> mBoundProxyService is NULL"); + } + } + + /** + * Adds command ID to the adapter, and maps it to its parent submenu. + * + * @param cmdID ID of the new command + * @param submenuID ID of the command's parent submenu + */ + private void addCommandToList(Integer cmdID, Integer submenuID) { + mCommandAdapter.add(cmdID); + if (null != submenuID) { + mCommandIdToParentSubmenuMap.put(cmdID, submenuID); + } + } + + /** + * Removes command ID from the adapter. + * + * @param cmdID ID of the command + */ + private void removeCommandFromList(Integer cmdID) { + mCommandAdapter.remove(cmdID); + mCommandIdToParentSubmenuMap.remove(cmdID); + } + + //upon onDestroy(), dispose current proxy and create a new one to enable auto-start + //call resetProxy() to do so + /*public void endSyncProxyInstance() { + if (mBoundProxyService != null) { + SyncProxyALM proxyInstance = mBoundProxyService.getProxyInstance(); + //if proxy exists, reset it + if (proxyInstance != null) { + if (proxyInstance.getCurrentTransportType() == TransportType.BLUETOOTH) { + mBoundProxyService.reset(); + } else { + Log.e(LOG_TAG, "endSyncProxyInstance. No reset required if transport is TCP"); + } + //if proxy == null create proxy + } else { + mBoundProxyService.startProxy(); + } + } + }*/ + + public void setTesterMain(ModuleTest _instance) { + this._testerMain = _instance; + } + + @Override + public void onBackPressed() { + super.onBackPressed(); + saveMessageSelectCount(); + } + + @Override + public void onPause() { + super.onPause(); + saveMessageSelectCount(); + } + + /** + * Return a clone of the {@code isVehicleDataSubscribed} + * @return a clone of the {@code isVehicleDataSubscribed} + */ + public boolean[] cloneIsVehicleDataSubscribed() { + return isVehicleDataSubscribed.clone(); + } + + /** + * + * @param position position in the array + * @return + */ + public boolean getIsVehicleDataSubscribedAt(int position) { + return isVehicleDataSubscribed[position]; + } + + /** + * Set a velue of the {@code isVehicleDataSubscribed} array + * @param value + */ + public void setIsVehicleDataSubscribed(boolean[] value) { + isVehicleDataSubscribed = value; + } + + /** + * Called when a CreateChoiceSetResponse comes. If successful, add it to the + * adapter. In any case, remove the key from the map. + */ + public void onCreateChoiceSetResponse(boolean success) { + if (mLatestCreateChoiceSetId != CHOICESETID_UNSET) { + if (success) { + mChoiceSetAdapter.add(mLatestCreateChoiceSetId); + } + mLatestCreateChoiceSetId = CHOICESETID_UNSET; + } else { + Log.w(LOG_TAG, "Latest createChoiceSetId is unset"); + } + } + + /** + * Called when a DeleteChoiceSetResponse comes. If successful, remove it + * from the adapter. + */ + public void onDeleteChoiceSetResponse(boolean success) { + if (_latestDeleteChoiceSetId != CHOICESETID_UNSET) { + if (success) { + mChoiceSetAdapter.remove(_latestDeleteChoiceSetId); + } + _latestDeleteChoiceSetId = CHOICESETID_UNSET; + } else { + Log.w(LOG_TAG, "Latest deleteChoiceSetId is unset"); + } + } + + /** + * Called when a DeleteSubMenuResponse comes. If successful, remove it from + * the adapter. We also need to delete all the commands that were added to + * this submenu. + */ + public void onDeleteSubMenuResponse(boolean success) { + if (_latestDeleteSubmenu != null) { + if (success) { + mSubmenuAdapter.remove(_latestDeleteSubmenu); + + for (Iterator<Entry<Integer, Integer>> it = mCommandIdToParentSubmenuMap + .entrySet().iterator(); it.hasNext(); ) { + Entry<Integer, Integer> entry = it.next(); + if (entry.getValue() == _latestDeleteSubmenu.getSubMenuId()) { + mCommandAdapter.remove(entry.getKey()); + it.remove(); + } + } + } + _latestDeleteSubmenu = null; + } else { + Log.w(LOG_TAG, "Latest deleteSubMenu is unset"); + } + } + + /** + * Called when a AddSubMenuResponse comes. If successful, add it to the + * adapter. + */ + public void onAddSubMenuResponse(boolean success) { + if (mLatestAddSubmenu != null) { + if (success) { + addSubMenuToList(mLatestAddSubmenu); + } + mLatestAddSubmenu = null; + } else { + Log.w(LOG_TAG, "Latest addSubMenu is unset"); + } + } + + /** + * Called when a AddCommandResponse comes. If successful, add it to the + * adapter. + */ + public void onAddCommandResponse(boolean success) { + if (mLatestAddCommand != null) { + if (success) { + addCommandToList(mLatestAddCommand.first, mLatestAddCommand.second); + } + mLatestAddCommand = null; + } else { + Log.w(LOG_TAG, "Latest addCommand is unset"); + } + } + + /** + * Called when a DeleteCommandResponse comes. If successful, remove it from + * the adapter. + */ + public void onDeleteCommandResponse(boolean success) { + if (_latestDeleteCommandCmdID != null) { + if (success) { + removeCommandFromList(_latestDeleteCommandCmdID); + } + _latestDeleteCommandCmdID = null; + } else { + Log.w(LOG_TAG, "Latest deleteCommand is unset"); + } + } + + /** + * Called whenever an OnAudioPassThru notification comes. The aptData is the + * audio data sent in it. + */ + public void onAudioPassThru(byte[] aptData) { + if (aptData == null) { + Log.w(LOG_TAG, "onAudioPassThru aptData is null"); + return; + } + Log.i(LOG_TAG, "data len " + aptData.length); + + File outFile = audioPassThruOutputFile(); + try { + if (audioPassThruOutStream == null) { + audioPassThruOutStream = new BufferedOutputStream( + new FileOutputStream(outFile, false)); + } + audioPassThruOutStream.write(aptData); + audioPassThruOutStream.flush(); + } catch (FileNotFoundException e) { + logToConsoleAndUI( + "Output file " + + (outFile != null ? outFile.toString() + : "'unknown'") + + " can't be opened for writing", e); + } catch (IOException e) { + logToConsoleAndUI("Can't write to output file", e); + } + + /* + * if there is current player, save the current position, stop and + * release it, so that we recreate it with the appended file and jump to + * that position, emulating seamless stream playing + */ + int audioPosition = -1; + if (audioPassThruMediaPlayer != null) { + audioPosition = audioPassThruMediaPlayer.getCurrentPosition(); + audioPassThruMediaPlayer.stop(); + audioPassThruMediaPlayer.reset(); + audioPassThruMediaPlayer.release(); + audioPassThruMediaPlayer = null; + } + + audioPassThruMediaPlayer = new MediaPlayer(); + try { + if (isExtStorageWritable()) { + audioPassThruMediaPlayer.setDataSource(outFile.toString()); + } else { + /* + * setDataSource with a filename on the internal storage throws + * "java.io.IOException: Prepare failed.: status=0x1", so we + * open the file with a special method + */ + audioPassThruMediaPlayer.setDataSource(openFileInput( + AUDIOPASSTHRU_OUTPUT_FILE).getFD()); + } + audioPassThruMediaPlayer.prepare(); + if (audioPosition != -1) { + audioPassThruMediaPlayer.seekTo(audioPosition); + } + audioPassThruMediaPlayer.start(); + } catch (IOException e) { + Log.e(LOG_TAG, e.toString()); + } + } + + /** + * Called when a PerformAudioPassThru response comes. Save the file only if + * the result is success. If the result is retry, send the latest request + * again. + */ + public void onPerformAudioPassThruResponse(Result result) { + closeAudioPassThruStream(); + closeAudioPassThruMediaPlayer(); + if (Result.SUCCESS != result) { + File outFile = audioPassThruOutputFile(); + if ((outFile != null) && outFile.exists()) { + if (!outFile.delete()) { + logToConsoleAndUI("Failed to delete output file", null); + } + } + + if ((Result.RETRY == result) && (latestPerformAudioPassThruMsg != null)) { + latestPerformAudioPassThruMsg.setCorrelationID(getCorrelationid()); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(latestPerformAudioPassThruMsg); + } + } + } + } + + /** + * Called when an EndAudioPassThru response comes. The logic is the same as + * when a PerformAudioPassThru response comes. + */ + public void onEndAudioPassThruResponse(Result result) { + onPerformAudioPassThruResponse(result); + } + + private void closeAudioPassThruStream() { + if (audioPassThruOutStream != null) { + Log.d(LOG_TAG, "closing audioPassThruOutStream"); + try { + audioPassThruOutStream.flush(); + audioPassThruOutStream.close(); + } catch (IOException e) { + Log.w(LOG_TAG, "Can't close output file", e); + } + audioPassThruOutStream = null; + } + } + + private void closeAudioPassThruMediaPlayer() { + if (audioPassThruMediaPlayer == null) { + return; + } + + if (audioPassThruMediaPlayer.isPlaying()) { + audioPassThruMediaPlayer.setOnCompletionListener(new OnCompletionListener() { + @Override + public void onCompletion(MediaPlayer mp) { + Log.d(LOG_TAG, "mediaPlayer completed"); + audioPassThruMediaPlayer.reset(); + audioPassThruMediaPlayer.release(); + audioPassThruMediaPlayer = null; + } + }); + } else { + // the player has stopped + Log.d(LOG_TAG, "mediaPlayer is stopped"); + audioPassThruMediaPlayer.release(); + audioPassThruMediaPlayer = null; + } + } + + private File audioPassThruOutputFile() { + File baseDir = isExtStorageWritable() ? Environment + .getExternalStorageDirectory() : getFilesDir(); + File outFile = new File(baseDir, AUDIOPASSTHRU_OUTPUT_FILE); + return outFile; + } + + private void logToConsoleAndUI(String msg, Throwable thr) { + Log.d(LOG_TAG, msg, thr); + Toast.makeText(getApplicationContext(), msg, Toast.LENGTH_SHORT).show(); + } + + /** + * Returns whether the external storage is available for writing. + */ + private boolean isExtStorageWritable() { + String state = Environment.getExternalStorageState(); + return Environment.MEDIA_MOUNTED.equals(state); + } + + private void sendCreateInteractionChoiceSet(Vector<Choice> choices) { + int choiceSetID = autoIncChoiceSetId++; + if (mBoundProxyService != null) { + mBoundProxyService.commandCreateInteractionChoiceSetResumable(choices, choiceSetID, + getCorrelationid()); + + if (mLatestCreateChoiceSetId != CHOICESETID_UNSET) { + Log.w(LOG_TAG, "Latest createChoiceSetId should be unset, but equals to " + + mLatestCreateChoiceSetId); + } + mLatestCreateChoiceSetId = choiceSetID; + } + } + + @Override + protected void onActivityResult(int requestCode, int resultCode, Intent data) { + switch (requestCode) { + case REQUEST_LIST_SOFTBUTTONS: + if (resultCode == RESULT_OK) { + currentSoftButtons = (Vector<SoftButton>) IntentHelper. + getObjectForKey(Const.INTENTHELPER_KEY_OBJECTSLIST); + if (chkIncludeSoftButtons != null) { + chkIncludeSoftButtons.setChecked(true); + } + } + IntentHelper.removeObjectForKey(Const.INTENTHELPER_KEY_OBJECTSLIST); + break; + + case REQUEST_LIST_CHOICES: + if (resultCode == RESULT_OK) { + Vector<Choice> choices = (Vector<Choice>) IntentHelper. + getObjectForKey(Const.INTENTHELPER_KEY_OBJECTSLIST); + sendCreateInteractionChoiceSet(choices); + } + IntentHelper.removeObjectForKey(Const.INTENTHELPER_KEY_OBJECTSLIST); + break; + + case Const.REQUEST_FILE_OPEN: + if (resultCode == RESULT_OK) { + String fileName = data.getStringExtra(FileDialog.RESULT_PATH); + if (txtLocalFileName != null) { + txtLocalFileName.setText(fileName); + } + } + break; + + case REQUEST_CHOOSE_XML_TEST: + if (resultCode == RESULT_OK) { + String filePath = data.getStringExtra(FileDialog.RESULT_PATH); + if (filePath != null) { + xmlTestContinue(filePath); + } + } + break; + + default: + Log.i(LOG_TAG, "Unknown request code: " + requestCode); + break; + } + } + + /** + * Called when the app is acivated from HMI for the first time. ProxyService + * automatically subscribes to buttons, so we reflect that in the + * subscription list. + */ + public void buttonsSubscribed(Vector<ButtonName> buttons) { + List<ButtonName> buttonNames = Arrays.asList(ButtonName.values()); + for (ButtonName buttonName : buttons) { + isButtonSubscribed[buttonNames.indexOf(buttonName)] = true; + } + } + + /** + * Opens a dialog so that the user can select an XML test or a directory + * with XML tests. The result will come to onActivityResult method. + */ + public void openXmlFilePathDialog() { + Intent intent = new Intent(this, FileDialog.class); + String sdcardPath = Environment.getExternalStorageDirectory().getPath(); + intent.putExtra(FileDialog.START_PATH, sdcardPath); + intent.putExtra(FileDialog.CAN_SELECT_DIR, true); + intent.putExtra(FileDialog.SELECTION_MODE, SelectionMode.MODE_OPEN); + intent.putExtra(FileDialog.FORMAT_FILTER, new String[]{"xml"}); + startActivityForResult(intent, REQUEST_CHOOSE_XML_TEST); + } + + public void startMobileNaviService() { + if (isProxyReadyForWork()) { + if (mBoundProxyService != null) { + mLogAdapter.logMessage("Should start Mobile Navi Service", true); + mBoundProxyService.syncProxyStartMobileNavService(rpcSession); + } else { + mLogAdapter.logMessage("Could not start mobile nav Service", true); + } + } + } + + public void onMobileNaviError(String errorMsg) { + onMobileNaviError(errorMsg, true); + } + + public void onMobileNaviError(String errorMsg, boolean addToUI) { + mLogAdapter.logMessage(errorMsg, addToUI); + MobileNavPreviewFragment fr = (MobileNavPreviewFragment) getSupportFragmentManager().findFragmentById(R.id.videoFragment); + fr.setStateOff(); + closeMobileNaviOutputStream(); + AudioServicePreviewFragment audioFragement = (AudioServicePreviewFragment) getSupportFragmentManager().findFragmentById(R.id.audioFragment); + audioFragement.setStateOff(); + closeAudioOutputStream(); + } + + public void logError(final Exception e) { + runOnUiThread(new Runnable() { + @Override + public void run() { + mLogAdapter.logMessage(e.getMessage(), true); + } + }); + } + + private void closeMobileNaviOutputStream() { + if (mBoundProxyService != null) { + mBoundProxyService.syncProxyStopH264(); + } + } + + private void closeAudioOutputStream() { + if (mBoundProxyService != null) { + mBoundProxyService.syncProxyStopAudioDataTransfer(); + } + } + + public void stopMobileNavService() { + mStreamCommandsExecutorService.submit(new Runnable() { + @Override + public void run() { + if (isProxyReadyForWork()) { + mLogAdapter.logMessage("Should stop Mobile Navi service", true); + if (mBoundProxyService != null) { + mBoundProxyService.syncProxyStopMobileNaviService(); + } + closeMobileNaviOutputStream(); + } + } + }); + } + + public boolean isProxyReadyForWork() { + if (mBoundProxyService == null) { + return false; + } + if (!mBoundProxyService.isSyncProxyNotNull()) { + onMobileNaviError("Error. Proxy is null"); + return false; + } + if (!mBoundProxyService.isSyncProxyConnected()) { + onMobileNaviError("Error. Proxy is not connected"); + return false; + } + if (!mBoundProxyService.isSyncProxyConnectionNotNull()) { + onMobileNaviError("Error. sync connection is null"); + return false; + } + return true; + } + + public void startAudioService() { + if (isProxyReadyForWork()) { + mLogAdapter.logMessage("Should start Mobile Audio service", true); + + mStreamCommandsExecutorService.submit(new Runnable() { + @Override + public void run() { + mBoundProxyService.syncProxyStartAudioService(rpcSession); + } + }); + } + } + + public void stopAudioService() { + mStreamCommandsExecutorService.submit(new Runnable() { + @Override + public void run() { + if (isProxyReadyForWork()) { + mLogAdapter.logMessage("Should stop Mobile Audio service", true); + mBoundProxyService.syncProxyStopAudioService(); + closeAudioOutputStream(); + } + } + }); + } + + public void onTouchEventReceived(OnTouchEvent notification) { + + } + + public void onKeyboardInputReceived(OnKeyboardInput event) { + + } + + /** + * Add all necessary listeners + */ + private void addListeners() { + ConnectionListenersManager.addConnectionListener(this); + } + + /** + * Remove all subscribed listeners + */ + private void removeListeners() { + ConnectionListenersManager.removeConnectionListener(this); + } + + /** + * Callback of the exit timer. If the correct destroy procedure fails we use Process.killProcess + */ + private Runnable mBluetoothStopServicePostDelayedCallback = new Runnable() { + @Override + public void run() { + Log.w(LOG_TAG, "Bluetooth Stop Service timer callback"); + mBluetoothStopProxyServiceTimeOutHandler.removeCallbacks(mBluetoothStopServicePostDelayedCallback); + stopService(new Intent(SyncProxyTester.this, ProxyService.class)); + } + }; + + /** + * Exit Application section + */ + + /** + * Exit from Activity + */ + private void exitApp() { + Log.i(LOG_TAG, "Exit App"); + isFirstActivityRun = true; + //stopService(new Intent(this, ProxyService.class)); + super.finish(); + + MainApp.getInstance().exitApp(); + } + + // TODO : Move this block to MainApp + /** + * Stops the proxy service. + */ + private void stopProxyServiceOnExit() { + getExitDialog().show(); + + if (mStopProxyServiceTimeOutHandler == null) { + mStopProxyServiceTimeOutHandler = new Handler(); + } else { + mStopProxyServiceTimeOutHandler.removeCallbacks(mExitPostDelayedCallback); + } + + if (mStopServicesTimeOutHandler == null) { + mStopServicesTimeOutHandler = new Handler(); + } else { + mStopServicesTimeOutHandler.removeCallbacks(mEndServicesPostDelayedCallback); + } + + if (mBoundProxyService == null) { + return; + } + + mStopServicesTimeOutHandler.postDelayed(mEndServicesPostDelayedCallback, EXIT_TIMEOUT); + + if (mBoundProxyService.hasServiceInServicesPool(ServiceType.Audio_Service)) { + stopAudioService(); + } + + if (mBoundProxyService.hasServiceInServicesPool(ServiceType.Mobile_Nav)) { + stopMobileNavService(); + } + + if (mServicesCounter.get() == 1) { + executeDestroyService(); + } + } + + private void executeDestroyService() { + + if (mStopServicesTimeOutHandler != null) { + mStopServicesTimeOutHandler.removeCallbacks(mEndServicesPostDelayedCallback); + } + + ExecutorService executorService = Executors.newSingleThreadExecutor(); + executorService.submit(new Runnable() { + @Override + public void run() { + + Log.d(LOG_TAG, "Start Destroy Service"); + mStopProxyServiceTimeOutHandler.postDelayed(mExitPostDelayedCallback, EXIT_TIMEOUT); + + mBoundProxyService.destroyService(); + } + }); + } + + private ProgressDialog getExitDialog() { + if (mExitProgressDialog == null) { + mExitProgressDialog = new ProgressDialog(this); + mExitProgressDialog.setTitle(R.string.exit_dialog_title); + mExitProgressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER); + mExitProgressDialog.setIndeterminate(true); + } + return mExitProgressDialog; + } + + /** + * Callback of the exit timer. If the correct destroy procedure fails we use Process.killProcess + */ + private Runnable mExitPostDelayedCallback = new Runnable() { + @Override + public void run() { + Log.w(LOG_TAG, "Exit App timer callback"); + mStopProxyServiceTimeOutHandler.removeCallbacks(mExitPostDelayedCallback); + getExitDialog().dismiss(); + exitApp(); + android.os.Process.killProcess(android.os.Process.myPid()); + } + }; + + /** + * Callback of the End Services timer. + */ + private Runnable mEndServicesPostDelayedCallback = new Runnable() { + @Override + public void run() { + Log.w(LOG_TAG, "End Services callback"); + mStopServicesTimeOutHandler.removeCallbacks(mEndServicesPostDelayedCallback); + + executeDestroyService(); + } + }; + + public void onUSBNoSuchDeviceException() { + MainApp.getInstance().runInUIThread(new Runnable() { + @Override + public void run() { + AlertDialog.Builder builder = new AlertDialog.Builder(SyncProxyTester.this); + builder.setTitle("USB problem"); + builder.setMessage("Last session over USB was interrupted incorrectly.\nTry UNPLUG and PLUG USB cable again") + .setPositiveButton("OK", new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + + } + }); + builder.create().show(); + } + }); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/AudioServiceCheckboxState.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/AudioServiceCheckboxState.java new file mode 100644 index 000000000..4b18e94c0 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/AudioServiceCheckboxState.java @@ -0,0 +1,19 @@ +package com.ford.syncV4.android.activity.mobilenav; + +import android.content.Context; +import android.widget.CheckBox; + +import com.ford.syncV4.android.R; + +/** + * Created by Andrew Batutin on 1/24/14. + */ +public class AudioServiceCheckboxState extends CheckBoxState { + + public AudioServiceCheckboxState(CheckBox item, Context context) { + super(item, context); + hintString = getResources().getString(R.string.audio_service_hint); + textString = getResources().getString(R.string.audio_service_on); + setStateOff(); + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/AudioServicePreviewFragment.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/AudioServicePreviewFragment.java new file mode 100644 index 000000000..110fca307 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/AudioServicePreviewFragment.java @@ -0,0 +1,93 @@ +package com.ford.syncV4.android.activity.mobilenav; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.Button; +import android.widget.CheckBox; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.activity.SafeToast; +import com.ford.syncV4.android.activity.SyncProxyTester; +import com.ford.syncV4.protocol.enums.ServiceType; + +import java.io.OutputStream; + +/** + * Created by Andrew Batutin on 1/23/14. + */ +public class AudioServicePreviewFragment extends SyncServiceBaseFragment { + + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, + Bundle savedInstanceState) { + return inflater.inflate(R.layout.activity_audio_service_preview, container, true); + } + + @Override + public void onViewCreated(View view, Bundle savedInstanceState) { + super.onViewCreated(view, savedInstanceState); + initiateView(view); + } + + private void initiateView(View view) { + mDataStreamingButton = (Button) getView().findViewById(R.id.audio_file_streaming); + mDataStreamingButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + startBaseFileStreaming(R.raw.audio_pcm); + } + }); + CheckBox checkBox = (CheckBox) view.findViewById(R.id.audioServiceCheckBox); + checkBox.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + if (hasServiceInServicesPool(ServiceType.RPC)) { + onMobileNaviCheckBoxAction(view); + } else { + SafeToast.showToastAnyThread(getString(R.string.rpc_service_not_started)); + } + } + }); + mSessionCheckBoxState = new AudioServiceCheckboxState(checkBox, getActivity()); + mSessionCheckBoxState.setStateOff(); + } + + public void onMobileNaviCheckBoxAction(View v) { + changeMobileNaviCheckBoxState(); + } + + private void changeMobileNaviCheckBoxState() { + if (mSessionCheckBoxState.getState().equals(CheckBoxStateValue.OFF)) { + mSessionCheckBoxState.setStateDisabled(); + SyncProxyTester tester = (SyncProxyTester) getActivity(); + tester.startAudioService(); + } else if (mSessionCheckBoxState.getState().equals(CheckBoxStateValue.ON)) { + mFileStreamingLogic.resetStreaming(); + SyncProxyTester tester = (SyncProxyTester) getActivity(); + tester.stopAudioService(); + mSessionCheckBoxState.setStateOff(); + mDataStreamingButton.setEnabled(false); + } + } + + @Override + public void setStateOff() { + super.setStateOff(); + CheckBox box = (CheckBox) getView().findViewById(R.id.audioServiceCheckBox); + box.setChecked(false); + } + + public void setAudioServiceStateOn(OutputStream stream) { + mSessionCheckBoxState.setStateOn(); + mDataStreamingButton.setEnabled(true); + + mFileStreamingLogic.setOutputStream(stream); + mFileStreamingLogic.createStaticFileReader(); + if (mFileStreamingLogic.isStreamingInProgress()) { + startBaseFileStreaming(R.raw.audio_pcm); + } + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/CheckBoxState.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/CheckBoxState.java new file mode 100644 index 000000000..19e8c557a --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/CheckBoxState.java @@ -0,0 +1,58 @@ +package com.ford.syncV4.android.activity.mobilenav; + +import android.content.Context; +import android.content.res.Resources; +import android.widget.CheckBox; + +/** + * Created by Andrew Batutin on 8/30/13. + */ +public class CheckBoxState { + + protected final CheckBox item; + protected CheckBoxStateValue state; + protected String hintString; + protected String textString; + protected Context context; + + public CheckBoxState(CheckBox item, Context context) { + this.item = item; + this.context = context; + } + + public CheckBoxStateValue getState() { + return state; + } + + protected void setState(CheckBoxStateValue state) { + this.state = state; + } + + public CheckBox getItem() { + return item; + } + + protected Resources getResources() { + return context.getResources(); + } + + public void setStateDisabled() { + getItem().setEnabled(false); + setState(CheckBoxStateValue.DISABLED); + } + + public void setStateOff() { + getItem().setText(""); + getItem().setHint(hintString); + getItem().setEnabled(true); + getItem().setChecked(false); + setState(CheckBoxStateValue.OFF); + } + + public void setStateOn() { + getItem().setText(textString); + getItem().setEnabled(true); + getItem().setChecked(true); + setState(CheckBoxStateValue.ON); + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/CheckBoxStateValue.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/CheckBoxStateValue.java new file mode 100644 index 000000000..9732cc487 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/CheckBoxStateValue.java @@ -0,0 +1,10 @@ +package com.ford.syncV4.android.activity.mobilenav; + +/** + * Created by Andrew Batutin on 8/30/13. + */ +public enum CheckBoxStateValue { + + ON, OFF, DISABLED + +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/DataReaderListener.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/DataReaderListener.java new file mode 100644 index 000000000..52e42813e --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/DataReaderListener.java @@ -0,0 +1,12 @@ +package com.ford.syncV4.android.activity.mobilenav; + +/** + * Created by Andrew Batutin on 9/11/13. + */ +public interface DataReaderListener { + + public void onStartReading(); + public void onDataReceived(final byte [] data); + public void onCancelReading(); + public void onEndReading(); +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/FileStreamingLogic.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/FileStreamingLogic.java new file mode 100644 index 000000000..21a34808d --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/FileStreamingLogic.java @@ -0,0 +1,107 @@ +package com.ford.syncV4.android.activity.mobilenav; + +import android.os.AsyncTask; +import android.util.Log; + +import com.ford.syncV4.android.activity.SyncProxyTester; + +import java.io.IOException; +import java.io.OutputStream; + +public class FileStreamingLogic { + + private static final String TAG = "FileStreamingLogic"; + + private StaticFileReader staticFileReader; + private OutputStream outputStream; + private ServicePreviewFragmentInterface context; + private Integer fileResID; + /** + * Indicates whether stream is completed or not. + */ + private boolean mIsStreamingInProgress; + + public FileStreamingLogic(ServicePreviewFragmentInterface mobileNavPreviewFragment) { + context = mobileNavPreviewFragment; + } + + public OutputStream getOutputStream() { + return outputStream; + } + + public void setOutputStream(OutputStream stream) { + this.outputStream = stream; + } + + public Integer getFileResID() { + return fileResID; + } + + public void setFileResID(Integer fileResID) { + this.fileResID = fileResID; + } + + public void cancelStreaming() { + if (staticFileReader != null) { + staticFileReader.cancel(true); + } + } + + public void resetStreaming() { + mIsStreamingInProgress = false; + cancelStreaming(); + } + + public void startFileStreaming() { + if (staticFileReader == null || staticFileReader.getStatus() == AsyncTask.Status.FINISHED){ + createStaticFileReader(); + } + staticFileReader.execute(fileResID); + } + + public boolean isStreamingInProgress() { + return mIsStreamingInProgress; + } + + public void createStaticFileReader() { + + staticFileReader = new StaticFileReader(context.getActivity(), new DataReaderListener() { + + @Override + public void onStartReading() { + Log.d(TAG, "On Start reading"); + mIsStreamingInProgress = true; + context.dataStreamingStarted(); + } + + @Override + public void onDataReceived(final byte[] data) { + if (outputStream != null && data != null) { + try { + //Log.d(TAG, "On read data:" + data); + outputStream.write(data); + } catch (IOException e) { + Log.e(TAG, "FIle streamer error", e); + cancelStreaming(); + SyncProxyTester tester = (SyncProxyTester) context.getActivity(); + + tester.logError(e); + } + } + } + + @Override + public void onCancelReading() { + Log.d(TAG, "On Cancel reading"); + context.dataStreamingStopped(); + } + + @Override + public void onEndReading() { + Log.d(TAG, "On Complete reading"); + mIsStreamingInProgress = false; + context.dataStreamingStopped(); + } + }); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/MobileNavPreviewFragment.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/MobileNavPreviewFragment.java new file mode 100644 index 000000000..96b764182 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/MobileNavPreviewFragment.java @@ -0,0 +1,120 @@ +package com.ford.syncV4.android.activity.mobilenav; + +import android.content.SharedPreferences; +import android.os.Bundle; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.Button; +import android.widget.CheckBox; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.activity.SafeToast; +import com.ford.syncV4.android.activity.SyncProxyTester; +import com.ford.syncV4.android.constants.Const; +import com.ford.syncV4.protocol.enums.ServiceType; + +import java.io.OutputStream; + +public class MobileNavPreviewFragment extends SyncServiceBaseFragment { + + private static final String TAG = MobileNavPreviewFragment.class.getSimpleName(); + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, + Bundle savedInstanceState) { + return inflater.inflate(R.layout.activity_mobile_nav_preview, container, true); + } + + @Override + public void onViewCreated(View view, Bundle savedInstanceState) { + super.onViewCreated(view, savedInstanceState); + initiateView(view); + } + + public void onMobileNaviCheckBoxAction(View v) { + changeMobileNaviCheckBoxState(); + } + + @Override + public void setStateOff() { + super.setStateOff(); + CheckBox box = (CheckBox) getView().findViewById(R.id.mobileNavCheckBox); + box.setChecked(false); + Button button = (Button) getView().findViewById(R.id.videobutton); + button.setEnabled(false); + } + + public void setMobileNaviStateOn(OutputStream stream) { + mSessionCheckBoxState.setStateOn(); + Button button = (Button) getView().findViewById(R.id.videobutton); + button.setEnabled(true); + mDataStreamingButton.setEnabled(true); + + mFileStreamingLogic.setOutputStream(stream); + mFileStreamingLogic.createStaticFileReader(); + if (mFileStreamingLogic.isStreamingInProgress()) { + startFileStreaming(); + } + } + + private void initiateView(View view) { + mDataStreamingButton = (Button) getView().findViewById(R.id.file_streaming); + mDataStreamingButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + startFileStreaming(); + } + }); + CheckBox checkBox = (CheckBox) view.findViewById(R.id.mobileNavCheckBox); + checkBox.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + if (hasServiceInServicesPool(ServiceType.RPC)) { + onMobileNaviCheckBoxAction(view); + } else { + SafeToast.showToastAnyThread(getString(R.string.rpc_service_not_started)); + } + } + }); + mSessionCheckBoxState = new MobileNaviCheckBoxState(checkBox, getActivity()); + mSessionCheckBoxState.setStateOff(); + } + + private void changeMobileNaviCheckBoxState() { + if (mSessionCheckBoxState.getState().equals(CheckBoxStateValue.OFF)) { + mSessionCheckBoxState.setStateDisabled(); + SyncProxyTester tester = (SyncProxyTester) getActivity(); + tester.startMobileNaviService(); + } else if (mSessionCheckBoxState.getState().equals(CheckBoxStateValue.ON)) { + mFileStreamingLogic.resetStreaming(); + SyncProxyTester tester = (SyncProxyTester) getActivity(); + tester.stopMobileNavService(); + mSessionCheckBoxState.setStateOff(); + Button button = (Button) getView().findViewById(R.id.videobutton); + button.setEnabled(false); + } + } + + private void startFileStreaming() { + SharedPreferences prefs = getActivity().getSharedPreferences(Const.PREFS_NAME, 0); + int videoSource = prefs.getInt(Const.PREFS_KEY_NAVI_VIDEOSOURCE, + Const.PREFS_DEFAULT_NAVI_VIDEOSOURCE); + int videoResID; + switch (videoSource) { + case Const.KEY_VIDEOSOURCE_MP4: + videoResID = R.raw.faq_welcome_orientation; + break; + + case Const.KEY_VIDEOSOURCE_H264: + videoResID = R.raw.faq_welcome_orientation_rawh264; + break; + + default: + Log.e(TAG, "Unknown video source " + videoSource); + return; + } + startBaseFileStreaming(videoResID); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/MobileNaviCheckBoxState.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/MobileNaviCheckBoxState.java new file mode 100644 index 000000000..88ac7b896 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/MobileNaviCheckBoxState.java @@ -0,0 +1,19 @@ +package com.ford.syncV4.android.activity.mobilenav; + +import android.content.Context; +import android.widget.CheckBox; + +import com.ford.syncV4.android.R; + +/** + * Created by Andrew Batutin on 8/30/13. + */ +public class MobileNaviCheckBoxState extends CheckBoxState { + + public MobileNaviCheckBoxState(CheckBox item, Context context) { + super(item, context); + hintString = getResources().getString(R.string.mobile_navi_hint); + textString = getResources().getString(R.string.mobile_navi_check_box_on); + setStateOff(); + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/MockVideoDataSource.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/MockVideoDataSource.java new file mode 100644 index 000000000..2707c3ede --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/MockVideoDataSource.java @@ -0,0 +1,55 @@ +package com.ford.syncV4.android.activity.mobilenav; + +/** + * Created by Andrew Batutin on 9/2/13. + */ +public class MockVideoDataSource implements Runnable { + + private static byte[] mockData = new byte[100]; + private VideoDataListener dataListener; + private Thread thread; + + public MockVideoDataSource(VideoDataListener dataListener) throws IllegalArgumentException { + if (dataListener == null) { + throw new IllegalArgumentException("listener should not be null"); + } + + this.dataListener = dataListener; + thread = new Thread(this); + } + + public VideoDataListener getDataListener() { + return dataListener; + } + + public Thread getThread() { + return thread; + } + + @Override + public void run() { + while (!Thread.interrupted()) { + dispatchDataToListener(); + } + } + + public void dispatchDataToListener() { + dataListener.videoFrameReady(createMockData()); + } + + byte[] createMockData() { + return mockData; + } + + public synchronized void start() { + if (thread.getState().equals(Thread.State.NEW)) { + thread.start(); + dataListener.onStreamingStart(); + } + } + + public synchronized void stop() { + thread.interrupt(); + dataListener.onStreamStop(); + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/ServicePreviewFragmentInterface.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/ServicePreviewFragmentInterface.java new file mode 100644 index 000000000..0a832ed00 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/ServicePreviewFragmentInterface.java @@ -0,0 +1,15 @@ +package com.ford.syncV4.android.activity.mobilenav; + +import android.app.Activity; + +/** + * Created by Andrew Batutin on 1/23/14. + */ +public interface ServicePreviewFragmentInterface { + + public void dataStreamingStarted(); + + public void dataStreamingStopped(); + + public Activity getActivity(); +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/StaticFileReader.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/StaticFileReader.java new file mode 100644 index 000000000..8d867f948 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/StaticFileReader.java @@ -0,0 +1,69 @@ +package com.ford.syncV4.android.activity.mobilenav; + +import android.app.Activity; +import android.os.AsyncTask; +import android.util.Log; + +import java.io.IOException; +import java.io.InputStream; + +/** + * Created by Andrew Batutin on 9/11/13. + */ +public class StaticFileReader extends AsyncTask<Integer, byte[], Void> { + + private final Activity mContext; + private DataReaderListener mListener; + + public StaticFileReader(Activity context, DataReaderListener listener) { + mContext = context; + mListener = listener; + } + + @Override + protected void onPreExecute() { + super.onPreExecute(); + mListener.onStartReading(); + } + + @Override + protected Void doInBackground(Integer... ids) { + Thread.currentThread().setName(this.getClass().getSimpleName()); + if (ids != null && ids.length > 0) { + readFileFromRaw(ids[0]); + } + return null; + } + + private synchronized void readFileFromRaw(Integer id) { + // Open the input stream + InputStream is = mContext.getResources().openRawResource(id); + byte[] buffer = new byte[1000]; + int length; + try { + while ((length = is.read(buffer)) != -1 && !isCancelled()) { + mListener.onDataReceived(buffer); + } + is.close(); + } catch (IOException e) { + Log.e("SyncProxyTester", e.toString()); + } + } + + @Override + protected void onProgressUpdate(byte[]... values) { + super.onProgressUpdate(values); + } + + @Override + protected void onPostExecute(Void aVoid) { + super.onPostExecute(aVoid); + mListener.onEndReading(); + } + + @Override + protected void onCancelled() { + super.onCancelled(); + mListener.onCancelReading(); + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/SyncServiceBaseFragment.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/SyncServiceBaseFragment.java new file mode 100644 index 000000000..a10f5b565 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/SyncServiceBaseFragment.java @@ -0,0 +1,98 @@ +package com.ford.syncV4.android.activity.mobilenav; + +import android.os.Bundle; +import android.support.v4.app.Fragment; +import android.widget.Button; + +import com.ford.syncV4.android.MainApp; +import com.ford.syncV4.android.listener.ConnectionListener; +import com.ford.syncV4.android.listener.ConnectionListenersManager; +import com.ford.syncV4.android.service.ProxyService; +import com.ford.syncV4.protocol.enums.ServiceType; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 2/6/14 + * Time: 3:18 PM + */ +public class SyncServiceBaseFragment extends Fragment implements ServicePreviewFragmentInterface, + ConnectionListener { + + private static final String TAG = SyncServiceBaseFragment.class.getSimpleName(); + + protected Button mDataStreamingButton; + protected CheckBoxState mSessionCheckBoxState; + protected FileStreamingLogic mFileStreamingLogic; + + @Override + public void onProxyClosed() { + if (mFileStreamingLogic != null && mFileStreamingLogic.isStreamingInProgress()) { + mFileStreamingLogic.cancelStreaming(); + } + } + + @Override + public void dataStreamingStarted() { + mDataStreamingButton.setEnabled(false); + mDataStreamingButton.setText("Data is streaming"); + } + + @Override + public void dataStreamingStopped() { + if (mSessionCheckBoxState.getState() == CheckBoxStateValue.ON) { + mDataStreamingButton.setEnabled(true); + } else { + mDataStreamingButton.setEnabled(false); + } + mDataStreamingButton.setText("Start File Streaming"); + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + mFileStreamingLogic = new FileStreamingLogic(this); + addListeners(); + } + + @Override + public void onDestroy() { + super.onDestroy(); + + removeListeners(); + } + + protected void startBaseFileStreaming(int resourceId) { + mFileStreamingLogic.setFileResID(resourceId); + mFileStreamingLogic.startFileStreaming(); + } + + protected boolean hasServiceInServicesPool(ServiceType serviceType) { + if (serviceType == null) { + return false; + } + ProxyService proxyService = MainApp.getInstance().getBoundProxyService(); + return proxyService != null && proxyService.hasServiceInServicesPool(serviceType); + } + + protected void setStateOff() { + mFileStreamingLogic.resetStreaming(); + mSessionCheckBoxState.setStateOff(); + mDataStreamingButton.setEnabled(false); + } + + /** + * Add all necessary listeners + */ + private void addListeners() { + ConnectionListenersManager.addConnectionListener(this); + } + + /** + * Remove all subscribed listeners + */ + private void removeListeners() { + ConnectionListenersManager.removeConnectionListener(this); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/VideoCheckBoxState.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/VideoCheckBoxState.java new file mode 100644 index 000000000..77fe7de8c --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/VideoCheckBoxState.java @@ -0,0 +1,19 @@ +package com.ford.syncV4.android.activity.mobilenav; + +import android.content.Context; +import android.widget.CheckBox; + +import com.ford.syncV4.android.R; + +/** + * Created by Andrew Batutin on 8/30/13. + */ +public class VideoCheckBoxState extends CheckBoxState { + + public VideoCheckBoxState(CheckBox item, Context context) { + super(item, context); + hintString = getResources().getString(R.string.video_streaming_hint); + textString = getResources().getString(R.string.video_check_box_on); + setStateOff(); + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/VideoDataListener.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/VideoDataListener.java new file mode 100644 index 000000000..dff1b82f0 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/activity/mobilenav/VideoDataListener.java @@ -0,0 +1,12 @@ +package com.ford.syncV4.android.activity.mobilenav; + +/** + * Created by Andrew Batutin on 9/2/13. + */ +public interface VideoDataListener { + public void onStreamingStart(); + + public void videoFrameReady(final byte[] videoFrame); + + public void onStreamStop(); +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/adapters/LogAdapter.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/adapters/LogAdapter.java new file mode 100644 index 000000000..65887ef3b --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/adapters/LogAdapter.java @@ -0,0 +1,148 @@ +package com.ford.syncV4.android.adapters; + +import android.app.Activity; +import android.util.Log; + +import java.util.ArrayList; + +public class LogAdapter extends MessageAdapter { + private String logTag; + boolean fullUIDebug; + Activity activity; + + public LogAdapter(String logTag, boolean fullUIDebug, Activity activity, + int textViewResourceId, ArrayList<Object> items) { + super(activity, textViewResourceId, items); + this.activity = activity; + this.logTag = logTag; + this.fullUIDebug = fullUIDebug; + } + + private void addMessageToUI(final Object m) { + activity.runOnUiThread(new Runnable() { + public void run() { + addMessage(m); + } + }); + } + + public void logMessage(final Object m) { + if (m == null) { + return; + } + Log.i(logTag, m.toString()); + if (fullUIDebug) { + addMessageToUI(m); + } + } + + public void logMessage(Object m, Boolean addToUI) { + if (m == null) { + return; + } + Log.i(logTag, m.toString()); + if (addToUI) { + addMessageToUI(m); + } + } + + public void logMessage(final Object m, Integer type) { + if (m instanceof String) { + switch (type) { + case Log.DEBUG: + Log.d(logTag, m.toString()); + break; + case Log.ERROR: + Log.e(logTag, m.toString()); + break; + case Log.VERBOSE: + Log.v(logTag, m.toString()); + break; + case Log.WARN: + Log.w(logTag, m.toString()); + break; + default: + Log.i(logTag, m.toString()); + break; + } + } + if (fullUIDebug) { + addMessageToUI(m); + } + } + + public void logMessage(final Object m, Integer type, Boolean addToUI) { + if (m instanceof String) { + switch (type) { + case Log.DEBUG: + Log.d(logTag, m.toString()); + break; + case Log.ERROR: + Log.e(logTag, m.toString()); + break; + case Log.VERBOSE: + Log.v(logTag, m.toString()); + break; + case Log.WARN: + Log.w(logTag, m.toString()); + break; + default: + Log.i(logTag, m.toString()); + break; + } + } + if (addToUI) { + addMessageToUI(m); + } + } + + public void logMessage(final Object m, Integer type, Throwable tr) { + if (m instanceof String) { + switch (type) { + case Log.DEBUG: + Log.d(logTag, m.toString()); + break; + case Log.ERROR: + Log.e(logTag, m.toString(), tr); + break; + case Log.VERBOSE: + Log.v(logTag, m.toString()); + break; + case Log.WARN: + Log.w(logTag, m.toString()); + break; + default: + Log.i(logTag, m.toString()); + break; + } + } + if (fullUIDebug) { + addMessageToUI(m); + } + } + + public void logMessage(final Object m, Integer type, Throwable tr, Boolean addToUI) { + if (m instanceof String) { + switch (type) { + case Log.DEBUG: + Log.d(logTag, m.toString()); + break; + case Log.ERROR: + Log.e(logTag, m.toString(), tr); + break; + case Log.VERBOSE: + Log.v(logTag, m.toString()); + break; + case Log.WARN: + Log.w(logTag, m.toString()); + break; + default: + Log.i(logTag, m.toString()); + break; + } + } + if (addToUI) { + addMessageToUI(m); + } + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/adapters/MessageAdapter.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/adapters/MessageAdapter.java new file mode 100644 index 000000000..d04db8667 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/adapters/MessageAdapter.java @@ -0,0 +1,125 @@ +package com.ford.syncV4.android.adapters; + +import android.content.Context; +import android.graphics.Color; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.ArrayAdapter; +import android.widget.TextView; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.proxy.RPCMessage; +import com.ford.syncV4.proxy.constants.Names; +import com.ford.syncV4.proxy.rpc.enums.Result; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; + +public class MessageAdapter extends ArrayAdapter<Object> { + private LayoutInflater vi; + private ArrayList<Object> items; + + public MessageAdapter(Context context, int textViewResourceId, + ArrayList<Object> items) { + super(context, textViewResourceId, items); + this.vi = (LayoutInflater) context + .getSystemService(Context.LAYOUT_INFLATER_SERVICE); + this.items = items; + } + + /** Adds the specified message to the items list and notifies of the change. */ + public void addMessage(Object m) { + add(m); + } + + static class ViewHolder { + TextView lblTop; + TextView lblBottom; + } + + public View getView(int position, View convertView, ViewGroup parent) { + ViewHolder holder = null; + TextView lblTop = null; + TextView lblBottom = null; + + ViewGroup rowView = (ViewGroup) convertView; + if (rowView == null) { + rowView = (ViewGroup) vi.inflate(R.layout.row, null); + + lblTop = (TextView) rowView.findViewById(R.id.toptext); + lblBottom = (TextView) rowView.findViewById(R.id.bottomtext); + + holder = new ViewHolder(); + holder.lblTop = lblTop; + holder.lblBottom = lblBottom; + rowView.setTag(holder); + } else { + holder = (ViewHolder) rowView.getTag(); + lblTop = holder.lblTop; + lblBottom = holder.lblBottom; + + lblBottom.setVisibility(View.VISIBLE); + lblBottom.setText(null); + lblTop.setTextColor(getContext().getResources().getColor( + R.color.log_regular_text_color)); + lblTop.setText(null); + } + + Object rpcObj = getItem(position); + if (rpcObj != null) { + if (rpcObj instanceof String) { + lblTop.setText((String) rpcObj); + lblBottom.setVisibility(View.GONE); + } else if (rpcObj instanceof RPCMessage) { + RPCMessage func = (RPCMessage) rpcObj; + if (func.getMessageType().equals(Names.request)) { + lblTop.setTextColor(Color.CYAN); + } else if (func.getMessageType().equals(Names.notification)) { + lblTop.setTextColor(Color.YELLOW); + } else if (func.getMessageType().equals(Names.response)) { + lblTop.setTextColor(Color.argb(255, 32, 161, 32)); + } + + lblTop.setText(func.getFunctionName() + " (" + + func.getMessageType() + ")"); + + try { + Method getSuccessMethod = rpcObj.getClass().getMethod( + "getSuccess"); + boolean isSuccess = (Boolean) getSuccessMethod.invoke(func); + if (isSuccess) { + lblTop.setTextColor(Color.GREEN); + } else { + lblTop.setTextColor(Color.RED); + } + Method getInfoMethod = rpcObj.getClass().getMethod( + "getInfo"); + Method getResultCodeMethod = rpcObj.getClass().getMethod( + "getResultCode"); + + String info = (String) getInfoMethod.invoke(rpcObj); + Result result = (Result) getResultCodeMethod.invoke(rpcObj); + + lblBottom.setText(result + + (info != null ? ": " + info : "")); + + } catch (NoSuchMethodException e) { + lblBottom.setVisibility(View.GONE); + } catch (SecurityException e) { + Log.e("SyncProxyTester", e.toString()); + } catch (IllegalArgumentException e) { + Log.e("SyncProxyTester", e.toString()); + } catch (IllegalAccessException e) { + Log.e("SyncProxyTester", e.toString()); + } catch (InvocationTargetException e) { + Log.e("SyncProxyTester", e.toString()); + } + } + } + + return rowView; + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/AcceptedRPC.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/AcceptedRPC.java new file mode 100644 index 000000000..a4c6afd9d --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/AcceptedRPC.java @@ -0,0 +1,68 @@ +package com.ford.syncV4.android.constants; + +import java.util.ArrayList; + +import com.ford.syncV4.android.module.GenericRequest; +import com.ford.syncV4.proxy.constants.Names; + +public class AcceptedRPC { + ArrayList<String> acceptedRPC = new ArrayList<String>(); + + public AcceptedRPC() { + acceptedRPC.add(Names.RegisterAppInterface); + acceptedRPC.add(Names.UnregisterAppInterface); + acceptedRPC.add(Names.SetGlobalProperties); + acceptedRPC.add(Names.ResetGlobalProperties); + acceptedRPC.add(Names.AddCommand); + acceptedRPC.add(Names.DeleteCommand); + acceptedRPC.add(Names.AddSubMenu); + acceptedRPC.add(Names.DeleteSubMenu); + acceptedRPC.add(Names.CreateInteractionChoiceSet); + acceptedRPC.add(Names.PerformInteraction); + acceptedRPC.add(Names.DeleteInteractionChoiceSet); + acceptedRPC.add(Names.Alert); + acceptedRPC.add(Names.Show); + acceptedRPC.add(Names.Speak); + acceptedRPC.add(Names.SetMediaClockTimer); + acceptedRPC.add(Names.EncodedSyncPData); + acceptedRPC.add(Names.SyncPData); + acceptedRPC.add(Names.PerformAudioPassThru); + acceptedRPC.add(Names.EndAudioPassThru); + acceptedRPC.add(Names.SubscribeButton); + acceptedRPC.add(Names.UnsubscribeButton); + acceptedRPC.add(Names.SubscribeVehicleData); + acceptedRPC.add(Names.UnsubscribeVehicleData); + acceptedRPC.add(Names.GetVehicleData); + acceptedRPC.add(Names.ReadDID); + acceptedRPC.add(Names.GetDTCs); + acceptedRPC.add(Names.ScrollableMessage); + acceptedRPC.add(Names.Slider); + acceptedRPC.add(Names.ShowConstantTBT); + acceptedRPC.add(Names.AlertManeuver); + acceptedRPC.add(Names.UpdateTurnList); + acceptedRPC.add(Names.ChangeRegistration); + acceptedRPC.add(Names.PutFile); + acceptedRPC.add(Names.DeleteFile); + acceptedRPC.add(Names.ListFiles); + acceptedRPC.add(Names.SetAppIcon); + acceptedRPC.add(Names.SetDisplayLayout); + + acceptedRPC.add("ClearMediaClockTimer"); + acceptedRPC.add("PauseMediaClockTimer"); + acceptedRPC.add("ResumeMediaClockTimer"); + + acceptedRPC.add(GenericRequest.NAME); + } + + public String getFunctionName(int i) { + return acceptedRPC.get(i); + } + + public int getFunctionID(String functionName) { + return acceptedRPC.indexOf(functionName); + } + + public boolean isAcceptedRPC(String rpc) { + return acceptedRPC.contains(rpc); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/Const.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/Const.java new file mode 100644 index 000000000..cbe2b567c --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/Const.java @@ -0,0 +1,89 @@ +package com.ford.syncV4.android.constants; + +import com.ford.syncV4.proxy.rpc.enums.Language; + +/** Stores application-wide constants. */ +public class Const { + // Shared preference name for protocol properties + public static final String PREFS_NAME = "SyncProxyTesterPrefs"; + + // Protocol properties + public static final String PREFS_KEY_ISMEDIAAPP = "isMediaApp"; + public static final String PREFS_KEY_ISNAVIAPP = "isNaviApp"; + public static final String PREFS_KEY_NAVI_VIDEOSOURCE = "videoSrc"; + public static final String PREFS_KEY_APPNAME = "appName"; + public static final String PREFS_KEY_LANG = "desiredLang"; + public static final String PREFS_KEY_HMILANG = "desiredHMILang"; + public static final String PREFS_KEY_AUTOSETAPPICON = "autoSetAppIcon"; + public static final String PREFS_KEY_DISABLE_LOCK_WHEN_TESTING = "disableLockWhenTesting"; + + public static final int KEY_VIDEOSOURCE_MP4 = 0; + public static final int KEY_VIDEOSOURCE_H264 = 1; + + // Default values + public static final boolean PREFS_DEFAULT_ISMEDIAAPP = true; + public static final boolean PREFS_DEFAULT_ISNAVIAPP = true; + public static final int PREFS_DEFAULT_NAVI_VIDEOSOURCE = KEY_VIDEOSOURCE_MP4; + public static final String PREFS_DEFAULT_APPNAME = FlavorConst.PREFS_DEFAULT_APPNAME; + public static final String PREFS_DEFAULT_LANG = Language.EN_US.name(); + public static final String PREFS_DEFAULT_HMILANG = Language.EN_US.name(); + public static final boolean PREFS_DEFAULT_AUTOSETAPPICON = true; + public static final boolean PREFS_DEFAULT_DISABLE_LOCK_WHEN_TESTING = false; + + // Protocol version constants + public static final int PROTOCOL_VERSION_1 = 1; + public static final int PROTOCOL_VERSION_2 = 2; + + // Transport properties + public static final class Transport { + // Protocol properties + public static final String PREFS_KEY_TRANSPORT_TYPE = "TransportType"; + public static final String PREFS_KEY_TRANSPORT_PORT = "TCPPort"; + public static final String PREFS_KEY_TRANSPORT_IP = "IPAddress"; + public static final String PREFS_KEY_IS_NSD = "IsNSD"; + + public static final String TCP = "WiFi"; + public static final String BLUETOOTH = "Bluetooth"; + public static final String USB = "USB"; + public static final int KEY_UNKNOWN = -1; + public static final int KEY_TCP = 1; + public static final int KEY_BLUETOOTH = 2; + public static final int KEY_USB = 3; + + public static final int PREFS_DEFAULT_TRANSPORT_TYPE = KEY_USB; + public static final int PREFS_DEFAULT_TRANSPORT_PORT = 12345; + public static final String PREFS_DEFAULT_TRANSPORT_IP = "10.10.0.1"; + } + + // Policy properties + public static final class Policy { + public static final String PREF_KEY_POLICY_UPDATE_FILE_PATH = "PolicyUpdateFilePath"; + public static final String PREF_KEY_POLICY_UPDATE_AUTO_REPLAY = "PolicyUpdateAutoReplay"; + } + + // HashId properties + public static final class HashId { + public static final String PREF_KEY_USE_HASH_ID = "UseHashId"; + public static final String PREF_KEY_USE_CUSTOM_HASH_ID = "UseCustomHashId"; + public static final String PREF_KEY_CUSTOM_HASH_ID = "CustomHashId"; + public static final String PREF_KEY_LAST_HASH_IDS = "LastHashIds"; + } + + // Keys to pass objects via IntentHelper + public static final String INTENTHELPER_KEY_OBJECT = "IntentObject"; + public static final String INTENTHELPER_KEY_OBJECTSLIST = "IntentObjectsList"; + public static final String INTENTHELPER_KEY_KEYBOARDPROPERTIES = "IntentKeyboardProperties"; + public static final String INTENTHELPER_KEY_KEYBOARDPROPERTIES_EMPTY = "IntentKeyboardPropertiesEmpty"; + + // Keys to pass values via Intent + public static final String INTENT_KEY_OBJECTS_MAXNUMBER = "MaxObjectsNumber"; + + // Request id for KeyboardPropertiesActivity + public static final int REQUEST_EDIT_KBDPROPERTIES = 44; + + // Value of the Jellybean API level, to check on devices running API level lower then API 16 + public static final int JELLYBEAN_API_LEVEL = 16; + + public static final int REQUEST_FILE_OPEN = 50; + public static final int REQUEST_POLICY_UPDATE_FILE_OPEN = 51; +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/SyncSubMenu.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/SyncSubMenu.java new file mode 100644 index 000000000..9bd687870 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/SyncSubMenu.java @@ -0,0 +1,26 @@ +package com.ford.syncV4.android.constants; + +public class SyncSubMenu { + private String menuName; + private int id; + + public void setSubMenuId(int parentID) { + this.id = parentID; + } + + public int getSubMenuId() { + return this.id; + } + + public void setName(String name) { + this.menuName = name; + } + + public String getName() { + return this.menuName; + } + + public String toString() { + return "(" + getSubMenuId() + ") " + getName(); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/TestObj.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/TestObj.java new file mode 100644 index 000000000..1bbc208aa --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/TestObj.java @@ -0,0 +1,57 @@ +package com.ford.syncV4.android.constants; + +import java.util.Vector; + +import com.ford.syncV4.proxy.rpc.Choice; +import com.ford.syncV4.proxy.rpc.TTSChunk; +import com.ford.syncV4.proxy.rpc.enums.ButtonName; +import com.ford.syncV4.proxy.rpc.enums.GlobalProperty; +import com.ford.syncV4.proxy.rpc.enums.InteractionMode; +import com.ford.syncV4.proxy.rpc.enums.TextAlignment; +import com.ford.syncV4.proxy.rpc.enums.UpdateMode; + +public class TestObj { + public Boolean playTone = null; + public Integer choiceID = null; + public Vector<Choice> choiceSet = null; + public Integer commandID = null; + public Integer corrID = null; + public Integer duration = null; + public Integer hours = null; + public Integer interactionChoiceSetID = null; + public Vector<Integer> interactionChoiceSetIDList = null; + public Integer menuID = null; + public Integer minutes = null; + public Integer parentID = null; + public Integer position = null; + public Integer seconds = null; + public Integer timeout = null; + public String alertText1 = null; + public String alertText2 = null; + public String choiceMenuName = null; + public String displayText = null; + public String helpPrompt = null; + public Vector<TTSChunk> helpChunks = null; + public String initPrompt = null; + public Vector<TTSChunk> initChunks = null; + public String mainText1 = null; + public String mainText2 = null; + public String mediaClock = null; + public String mediaTrack = null; + public String menuName = null; + public String menuText = null; + public String RPC = null; + public String statusBar = null; + public String timeoutPrompt = null; + public Vector<TTSChunk> timeoutChunks = null; + public String ttsText = null; + public Vector<TTSChunk> ttsChunks = null; + public Vector<GlobalProperty> properties = null; + public Vector<String> data = null; + public Vector<String> choiceVrCommands = null; + public Vector<String> vrCommands = null; + public ButtonName buttonName = null; + public InteractionMode interactionMode = null; + public TextAlignment alignment = null; + public UpdateMode updateMode = null; +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/TestRPC.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/TestRPC.java new file mode 100644 index 000000000..f7b74bfd2 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/constants/TestRPC.java @@ -0,0 +1,242 @@ +package com.ford.syncV4.android.constants; + +import java.util.Vector; + +import android.util.Log; + +import com.ford.syncV4.proxy.RPCMessage; +import com.ford.syncV4.proxy.RPCRequest; +import com.ford.syncV4.proxy.RPCRequestFactory; +import com.ford.syncV4.proxy.TTSChunkFactory; +import com.ford.syncV4.proxy.constants.Names; +import com.ford.syncV4.proxy.rpc.Alert; +import com.ford.syncV4.proxy.rpc.AlertManeuver; +import com.ford.syncV4.proxy.rpc.ChangeRegistration; +import com.ford.syncV4.proxy.rpc.Choice; +import com.ford.syncV4.proxy.rpc.DeleteCommand; +import com.ford.syncV4.proxy.rpc.DeleteFile; +import com.ford.syncV4.proxy.rpc.DeleteInteractionChoiceSet; +import com.ford.syncV4.proxy.rpc.DeleteSubMenu; +import com.ford.syncV4.proxy.rpc.EncodedSyncPData; +import com.ford.syncV4.proxy.rpc.EndAudioPassThru; +import com.ford.syncV4.proxy.rpc.GetDTCs; +import com.ford.syncV4.proxy.rpc.GetVehicleData; +import com.ford.syncV4.proxy.rpc.ListFiles; +import com.ford.syncV4.proxy.rpc.PerformAudioPassThru; +import com.ford.syncV4.proxy.rpc.PerformInteraction; +import com.ford.syncV4.proxy.rpc.ReadDID; +import com.ford.syncV4.proxy.rpc.RegisterAppInterface; +import com.ford.syncV4.proxy.rpc.ResetGlobalProperties; +import com.ford.syncV4.proxy.rpc.ScrollableMessage; +import com.ford.syncV4.proxy.rpc.SetAppIcon; +import com.ford.syncV4.proxy.rpc.SetDisplayLayout; +import com.ford.syncV4.proxy.rpc.SetMediaClockTimer; +import com.ford.syncV4.proxy.rpc.Show; +import com.ford.syncV4.proxy.rpc.ShowConstantTBT; +import com.ford.syncV4.proxy.rpc.Slider; +import com.ford.syncV4.proxy.rpc.Speak; +import com.ford.syncV4.proxy.rpc.StartTime; +import com.ford.syncV4.proxy.rpc.SubscribeVehicleData; +import com.ford.syncV4.proxy.rpc.TTSChunk; +import com.ford.syncV4.proxy.rpc.UnregisterAppInterface; +import com.ford.syncV4.proxy.rpc.UnsubscribeButton; +import com.ford.syncV4.proxy.rpc.UnsubscribeVehicleData; +import com.ford.syncV4.proxy.rpc.UpdateTurnList; +import com.ford.syncV4.proxy.rpc.enums.ButtonName; +import com.ford.syncV4.proxy.rpc.enums.GlobalProperty; +import com.ford.syncV4.proxy.rpc.enums.InteractionMode; +import com.ford.syncV4.proxy.rpc.enums.TextAlignment; +import com.ford.syncV4.proxy.rpc.enums.UpdateMode; + +public class TestRPC { + Object rpc; + + public TestRPC(String functionName) { + if (functionName.equalsIgnoreCase(Names.RegisterAppInterface)) { + rpc = new RegisterAppInterface(); + } else if (functionName.equalsIgnoreCase(Names.UnregisterAppInterface)) { + rpc = new UnregisterAppInterface(); + } else if (functionName.equalsIgnoreCase(Names.SetGlobalProperties)) { + rpc = RPCRequestFactory.buildSetGlobalProperties(); + } else if (functionName.equalsIgnoreCase(Names.ResetGlobalProperties)) { + rpc = new ResetGlobalProperties(); + } else if (functionName.equalsIgnoreCase(Names.AddCommand)) { + rpc = RPCRequestFactory.buildAddCommand(); + } else if (functionName.equalsIgnoreCase(Names.DeleteCommand)) { + rpc = new DeleteCommand(); + } else if (functionName.equalsIgnoreCase(Names.AddSubMenu)) { + rpc = RPCRequestFactory.buildAddSubMenu(); + } else if (functionName.equalsIgnoreCase(Names.DeleteSubMenu)) { + rpc = new DeleteSubMenu(); + } else if (functionName.equalsIgnoreCase(Names.CreateInteractionChoiceSet)) { + rpc = RPCRequestFactory.buildCreateInteractionChoiceSet(); + } else if (functionName.equalsIgnoreCase(Names.PerformInteraction)) { + rpc = new PerformInteraction(); + } else if (functionName.equalsIgnoreCase(Names.DeleteInteractionChoiceSet)) { + rpc = new DeleteInteractionChoiceSet(); + } else if (functionName.equalsIgnoreCase(Names.Alert)) { + rpc = new Alert(); + } else if (functionName.equalsIgnoreCase(Names.Show)) { + rpc = new Show(); + } else if (functionName.equalsIgnoreCase(Names.Speak)) { + rpc = new Speak(); + } else if (functionName.equalsIgnoreCase(Names.SetMediaClockTimer)) { + rpc = new SetMediaClockTimer(); + } else if (functionName.equalsIgnoreCase(Names.EncodedSyncPData)) { + rpc = new EncodedSyncPData(); + } else if (functionName.equalsIgnoreCase(Names.PerformAudioPassThru)) { + rpc = new PerformAudioPassThru(); + } else if (functionName.equalsIgnoreCase(Names.EndAudioPassThru)) { + rpc = new EndAudioPassThru(); + } else if (functionName.equalsIgnoreCase(Names.SubscribeButton)) { + rpc = RPCRequestFactory.buildSubscribeButton(); + } else if (functionName.equalsIgnoreCase(Names.UnsubscribeButton)) { + rpc = new UnsubscribeButton(); + } else if (functionName.equalsIgnoreCase(Names.SubscribeVehicleData)) { + rpc = RPCRequestFactory.buildSubscribeVehicleData(); + } else if (functionName.equalsIgnoreCase(Names.UnsubscribeVehicleData)) { + rpc = new UnsubscribeVehicleData(); + } else if (functionName.equalsIgnoreCase(Names.GetVehicleData)) { + rpc = new GetVehicleData(); + } else if (functionName.equalsIgnoreCase(Names.ReadDID)) { + rpc = new ReadDID(); + } else if (functionName.equalsIgnoreCase(Names.GetDTCs)) { + rpc = new GetDTCs(); + } else if (functionName.equalsIgnoreCase(Names.ScrollableMessage)) { + rpc = new ScrollableMessage(); + } else if (functionName.equalsIgnoreCase(Names.Slider)) { + rpc = new Slider(); + } else if (functionName.equalsIgnoreCase(Names.ShowConstantTBT)) { + rpc = new ShowConstantTBT(); + } else if (functionName.equalsIgnoreCase(Names.AlertManeuver)) { + rpc = new AlertManeuver(); + } else if (functionName.equalsIgnoreCase(Names.UpdateTurnList)) { + rpc = new UpdateTurnList(); + } else if (functionName.equalsIgnoreCase(Names.ChangeRegistration)) { + rpc = new ChangeRegistration(); + } else if (functionName.equalsIgnoreCase(Names.PutFile)) { + rpc = RPCRequestFactory.buildPutFile(); + } else if (functionName.equalsIgnoreCase(Names.DeleteFile)) { + rpc = new DeleteFile(); + } else if (functionName.equalsIgnoreCase(Names.ListFiles)) { + rpc = new ListFiles(); + } else if (functionName.equalsIgnoreCase(Names.SetAppIcon)) { + rpc = new SetAppIcon(); + } else if (functionName.equalsIgnoreCase(Names.SetDisplayLayout)) { + rpc = new SetDisplayLayout(); + } else if (functionName.equalsIgnoreCase("ClearMediaClockTimer")) { + rpc = new Show(); + ((Show) rpc).setMainField1(null); + ((Show) rpc).setMainField2(null); + ((Show) rpc).setStatusBar(null); + ((Show) rpc).setMediaClock(" "); + ((Show) rpc).setMediaTrack(null); + ((Show) rpc).setAlignment(null); + } else if (functionName.equalsIgnoreCase("PauseMediaClockTimer")) { + rpc = new SetMediaClockTimer(); + StartTime startTime = new StartTime(); + startTime.setHours(0); + startTime.setMinutes(0); + startTime.setSeconds(0); + ((SetMediaClockTimer) rpc).setStartTime(startTime); + ((SetMediaClockTimer) rpc).setUpdateMode(UpdateMode.PAUSE); + } else if (functionName.equalsIgnoreCase("ResumeMediaClockTimer")) { + rpc = new SetMediaClockTimer(); + StartTime startTime = new StartTime(); + startTime.setHours(0); + startTime.setMinutes(0); + startTime.setSeconds(0); + ((SetMediaClockTimer) rpc).setStartTime(startTime); + ((SetMediaClockTimer) rpc).setUpdateMode(UpdateMode.RESUME); + } + } + + public RPCMessage getRPC() { + return (RPCMessage) rpc; + } + + public void setField(String field, String value) { + if (field.equalsIgnoreCase(Names.playTone)) { + if (value.equalsIgnoreCase("true")) ((RPCMessage) rpc).setParameters(field, true); + else if (value.equalsIgnoreCase("false")) ((RPCMessage) rpc).setParameters(field, false); + } else if (field.equalsIgnoreCase(Names.correlationID)) { + try {((RPCRequest) rpc).setCorrelationID(Integer.parseInt(value));} + catch (Exception e) {Log.e("parser", "Unable to parse Integer");} + } else if (field.equalsIgnoreCase(Names.choiceID) + || field.equalsIgnoreCase(Names.cmdID) + || field.equalsIgnoreCase(Names.correlationID) + || field.equalsIgnoreCase(Names.duration) + || field.equalsIgnoreCase(Names.menuID) + || field.equalsIgnoreCase(Names.parentID) + || field.equalsIgnoreCase(Names.position) + || field.equalsIgnoreCase(Names.timeout)) { + try {((RPCMessage) rpc).setParameters(field, Integer.parseInt(value));} + catch (Exception e) {Log.e("parser", "Unable to parse Integer");} + } else if (field.equalsIgnoreCase(Names.hours) + || field.equalsIgnoreCase(Names.minutes) + || field.equalsIgnoreCase(Names.seconds)) { + StartTime startTime = (StartTime) ((RPCMessage) rpc).getParameters(Names.startTime); + if (startTime == null) startTime = new StartTime(); + try { + if (field.equalsIgnoreCase(Names.hours)) startTime.setHours(Integer.parseInt(value)); + if (field.equalsIgnoreCase(Names.minutes)) startTime.setMinutes(Integer.parseInt(value)); + if (field.equalsIgnoreCase(Names.seconds)) startTime.setSeconds(Integer.parseInt(value)); + } catch (Exception e) {Log.e("parser", "Unable to parse Integer");} + } else if (field.equalsIgnoreCase(Names.interactionChoiceSetID) + || field.equalsIgnoreCase(Names.interactionChoiceSetIDList)) { + try { + if (((RPCMessage) rpc).getFunctionName().equalsIgnoreCase(Names.CreateInteractionChoiceSet) + || ((RPCMessage) rpc).getFunctionName().equalsIgnoreCase(Names.DeleteInteractionChoiceSet)) { + try {((RPCMessage) rpc).setParameters(field, Integer.parseInt(value));} + catch (Exception e) {Log.e("parser", "Unable to parse Integer");} + } else if (((RPCMessage) rpc).getFunctionName().equalsIgnoreCase(Names.PerformInteraction)) { + Vector<Integer> interactionChoiceSetIDs = new Vector<Integer>(); + interactionChoiceSetIDs.add(Integer.parseInt(value)); + ((RPCMessage) rpc).setParameters(Names.interactionChoiceSetIDList, interactionChoiceSetIDs); + }} catch (Exception e) {Log.e("parser", "Unable to parse Integer");} + } else if (field.equalsIgnoreCase(Names.alertText1) + || field.equalsIgnoreCase(Names.alertText2) + || field.equalsIgnoreCase(Names.initialText) + || field.equalsIgnoreCase(Names.mainField1) + || field.equalsIgnoreCase(Names.mainField2) + || field.equalsIgnoreCase(Names.mediaClock) + || field.equalsIgnoreCase(Names.mediaTrack) + || field.equalsIgnoreCase(Names.menuName) + || field.equalsIgnoreCase(Names.statusBar) + || field.equalsIgnoreCase(Names.data)) { + ((RPCMessage) rpc).setParameters(field ,value); + } else if (field.equalsIgnoreCase(Names.helpPrompt) + || field.equalsIgnoreCase(Names.initialPrompt) + || field.equalsIgnoreCase(Names.timeoutPrompt) + || field.equalsIgnoreCase(Names.ttsChunks)) { + Vector<TTSChunk> ttsChunks = TTSChunkFactory.createSimpleTTSChunks(value); + ((RPCMessage) rpc).setParameters(field, ttsChunks); + } else if (field.equalsIgnoreCase(Names.properties)) { + Vector<GlobalProperty> globalProperties = new Vector<GlobalProperty>(); + globalProperties.add(GlobalProperty.valueForString(value)); + ((RPCMessage) rpc).setParameters(field, globalProperties); + } else if (field.equalsIgnoreCase(Names.vrCommands)) { + Vector<String> vrCommands = new Vector<String>(); + vrCommands.add(new String(value)); + ((RPCMessage) rpc).setParameters(field, vrCommands); + } else if (field.equalsIgnoreCase(Names.buttonName)) { + ((RPCMessage) rpc).setParameters(field, ButtonName.valueForString(value)); + } else if (field.equalsIgnoreCase(Names.interactionMode)) { + ((RPCMessage) rpc).setParameters(field, InteractionMode.valueForString(value)); + } else if (field.equalsIgnoreCase(Names.alignment)) { + ((RPCMessage) rpc).setParameters(field, TextAlignment.valueForString(value)); + } else if (field.equalsIgnoreCase(Names.updateMode)) { + ((RPCMessage) rpc).setParameters(field, UpdateMode.valueForString(value)); + } else { + ((RPCMessage) rpc).setParameters(field, value); + } + } + + public void setChoiceSet(Vector<Choice> choiceSet) { + ((RPCMessage) rpc).setParameters(Names.choiceSet, choiceSet); + } + + public void setStartTime(StartTime startTime) { + ((RPCMessage) rpc).setParameters(Names.startTime, startTime); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/listener/ConnectionListener.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/listener/ConnectionListener.java new file mode 100644 index 000000000..96137278f --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/listener/ConnectionListener.java @@ -0,0 +1,11 @@ +package com.ford.syncV4.android.listener; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 1/27/14 + * Time: 10:44 AM + */ +public interface ConnectionListener { + void onProxyClosed(); +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/listener/ConnectionListenersManager.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/listener/ConnectionListenersManager.java new file mode 100644 index 000000000..349d41173 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/listener/ConnectionListenersManager.java @@ -0,0 +1,55 @@ +package com.ford.syncV4.android.listener; + +import java.lang.ref.WeakReference; +import java.util.ArrayList; +import java.util.List; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 1/27/14 + * Time: 11:11 AM + */ +public class ConnectionListenersManager { + + private static final List<WeakReference<ConnectionListener>> mConnectivityListeners = + new ArrayList<WeakReference<ConnectionListener>>(); + + public ConnectionListenersManager() { + + } + + /** + * Dispatch connection events described at ConnectionListener to the subscribed objects + */ + public void dispatch() { + for (WeakReference<ConnectionListener> reference : mConnectivityListeners) { + ConnectionListener callback = reference.get(); + if (callback != null) { + callback.onProxyClosed(); + } + } + } + + /** + * Add listener reference + * @param listener implementation of ConnectionListener interface + */ + public static synchronized void addConnectionListener(ConnectionListener listener) { + mConnectivityListeners.add(new WeakReference<ConnectionListener>(listener)); + } + + /** + * Remove listener reference + * @param listener implementation of ConnectionListener interface + */ + public static synchronized void removeConnectionListener(ConnectionListener listener) { + for (WeakReference<ConnectionListener> reference : mConnectivityListeners) { + ConnectionListener connectionListener = reference.get(); + if (listener.equals(connectionListener)) { + mConnectivityListeners.remove(reference); + return; + } + } + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/AppPreferencesManager.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/AppPreferencesManager.java new file mode 100644 index 000000000..f4a69db25 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/AppPreferencesManager.java @@ -0,0 +1,169 @@ +package com.ford.syncV4.android.manager; + +import android.content.Context; +import android.content.SharedPreferences; + +import com.ford.syncV4.android.constants.Const; + +import java.util.LinkedHashSet; +import java.util.Set; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 12/27/13 + * Time: 10:51 AM + */ +public class AppPreferencesManager { + + private static Context mAppContext; + + public static void setAppContext(Context aAppContext) { + if (mAppContext == null) { + mAppContext = aAppContext; + } + } + + /** + * Get Transport Type that application use. + * @return value of the Transport Type or -1 if the one undefined + */ + public static int getTransportType() { + if (mAppContext == null) { + return -1; + } + SharedPreferences sharedPreferences = mAppContext.getSharedPreferences(Const.PREFS_NAME, 0); + return sharedPreferences.getInt(Const.Transport.PREFS_KEY_TRANSPORT_TYPE, + Const.Transport.KEY_UNKNOWN); + } + + /** + * Set a path to the Policy Table Update file + * + * @param filePath path to the local file + */ + public static void setPolicyTableUpdateFilePath(String filePath) { + SharedPreferences sharedPreferences = mAppContext.getSharedPreferences(Const.PREFS_NAME, 0); + SharedPreferences.Editor editor = sharedPreferences.edit(); + editor.putString(Const.Policy.PREF_KEY_POLICY_UPDATE_FILE_PATH, filePath); + editor.commit(); + } + + /** + * Get a path to the Policy Table Update local file + * + * @return path to the file + */ + public static String getPolicyTableUpdateFilePath() { + SharedPreferences sharedPreferences = mAppContext.getSharedPreferences(Const.PREFS_NAME, 0); + return sharedPreferences.getString(Const.Policy.PREF_KEY_POLICY_UPDATE_FILE_PATH, ""); + } + + /** + * Set a value of the auto replay scenario in case of processing Policy Table Snapshot data + * + * @param value {@link java.lang.Boolean} true | false + */ + public static void setPolicyTableUpdateAutoReplay(boolean value) { + SharedPreferences sharedPreferences = mAppContext.getSharedPreferences(Const.PREFS_NAME, 0); + SharedPreferences.Editor editor = sharedPreferences.edit(); + editor.putBoolean(Const.Policy.PREF_KEY_POLICY_UPDATE_AUTO_REPLAY, value); + editor.commit(); + } + + /** + * Return a value of the auto replay scenario in case of processing Policy Table Snapshot data + * + * @return {@link java.lang.Boolean} true | false + */ + public static boolean getPolicyTableUpdateAutoReplay() { + SharedPreferences sharedPreferences = mAppContext.getSharedPreferences(Const.PREFS_NAME, 0); + return sharedPreferences.getBoolean(Const.Policy.PREF_KEY_POLICY_UPDATE_AUTO_REPLAY, true); + } + + /** + * Set <b>true</b> if application need to use HashId, <b>false</b> - otherwise + * + * @param value {@link java.lang.Boolean} true | false + */ + public static void setUseHashId(boolean value) { + SharedPreferences sharedPreferences = mAppContext.getSharedPreferences(Const.PREFS_NAME, 0); + SharedPreferences.Editor editor = sharedPreferences.edit(); + editor.putBoolean(Const.HashId.PREF_KEY_USE_HASH_ID, value); + editor.commit(); + } + + /** + * Return <b>true</b> if application need to use HashId, <b>false</b> - otherwise + * + * @return {@link java.lang.Boolean} true | false + */ + public static boolean getUseHashId() { + SharedPreferences sharedPreferences = mAppContext.getSharedPreferences(Const.PREFS_NAME, 0); + return sharedPreferences.getBoolean(Const.HashId.PREF_KEY_USE_HASH_ID, true); + } + + /** + * Set <b>true</b> if application need to use Custom HashId, <b>false</b> - otherwise + * + * @param value {@link java.lang.Boolean} true | false + */ + public static void setUseCustomHashId(boolean value) { + SharedPreferences sharedPreferences = mAppContext.getSharedPreferences(Const.PREFS_NAME, 0); + SharedPreferences.Editor editor = sharedPreferences.edit(); + editor.putBoolean(Const.HashId.PREF_KEY_USE_CUSTOM_HASH_ID, value); + editor.commit(); + } + + /** + * Return <b>true</b> if application need to use Custom HashId, <b>false</b> - otherwise + * + * @return {@link java.lang.Boolean} true | false + */ + public static boolean getUseCustomHashId() { + SharedPreferences sharedPreferences = mAppContext.getSharedPreferences(Const.PREFS_NAME, 0); + return sharedPreferences.getBoolean(Const.HashId.PREF_KEY_USE_CUSTOM_HASH_ID, false); + } + + /** + * Set custom {@link com.ford.syncV4.proxy.rpc.RegisterAppInterface#setHashID(String)} field + * value for the {@link com.ford.syncV4.proxy.rpc.RegisterAppInterface} + * + * @param value {@link java.lang.String} + */ + public static void setCustomHashId(String value) { + SharedPreferences sharedPreferences = mAppContext.getSharedPreferences(Const.PREFS_NAME, 0); + SharedPreferences.Editor editor = sharedPreferences.edit(); + editor.putString(Const.HashId.PREF_KEY_CUSTOM_HASH_ID, value); + editor.commit(); + } + + /** + * @return custom {@link com.ford.syncV4.proxy.rpc.RegisterAppInterface#setHashID(String)} + * field value for the {@link com.ford.syncV4.proxy.rpc.RegisterAppInterface} + */ + public static String getCustomHashId() { + SharedPreferences sharedPreferences = mAppContext.getSharedPreferences(Const.PREFS_NAME, 0); + return sharedPreferences.getString(Const.HashId.PREF_KEY_CUSTOM_HASH_ID, ""); + } + + /** + * Set last used {@link com.ford.syncV4.proxy.rpc.RegisterAppInterface#getHashID()} Set + * + * @param value {@link java.util.Set} + */ + public static void setLastUsedHashIds(String value) { + SharedPreferences sharedPreferences = mAppContext.getSharedPreferences(Const.PREFS_NAME, 0); + SharedPreferences.Editor editor = sharedPreferences.edit(); + editor.putString(Const.HashId.PREF_KEY_LAST_HASH_IDS, value); + editor.commit(); + } + + /** + * @return last used {@link com.ford.syncV4.proxy.rpc.RegisterAppInterface#getHashID()} Set + */ + public static String getLastUsedHashIds() { + SharedPreferences sharedPreferences = mAppContext.getSharedPreferences(Const.PREFS_NAME, 0); + return sharedPreferences.getString(Const.HashId.PREF_KEY_LAST_HASH_IDS, ""); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/BluetoothDeviceManager.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/BluetoothDeviceManager.java new file mode 100644 index 000000000..ba0ab4310 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/BluetoothDeviceManager.java @@ -0,0 +1,62 @@ +package com.ford.syncV4.android.manager; + +import android.bluetooth.BluetoothAdapter; + +import com.ford.syncV4.android.receivers.IBluetoothReceiver; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 12/26/13 + * Time: 5:47 PM + */ +public class BluetoothDeviceManager implements IBluetoothReceiver { + + private boolean mIsBluetoothEnabled = false; + private IBluetoothDeviceManager iBluetoothDeviceManagerCallback; + + public void setBluetoothDeviceManagerCallback(IBluetoothDeviceManager iBluetoothDeviceManagerCallback) { + this.iBluetoothDeviceManagerCallback = iBluetoothDeviceManagerCallback; + } + + public void initState() { + BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); + if (mBluetoothAdapter == null) { + // Bluetooth is not supported by device + } else { + if (!mBluetoothAdapter.isEnabled()) { + // Bluetooth is not enabled + mIsBluetoothEnabled = false; + //Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE); + //startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT); + } else { + // Bluetooth is enabled + mIsBluetoothEnabled = true; + } + } + } + + @Override + public void onBluetoothOn() { + if (!mIsBluetoothEnabled) { + if (iBluetoothDeviceManagerCallback != null) { + iBluetoothDeviceManagerCallback.onBluetoothDeviceRestoreConnection(); + } + } + mIsBluetoothEnabled = true; + } + + @Override + public void onBluetoothOff() { + mIsBluetoothEnabled = false; + } + + @Override + public void onBluetoothTurningOff() { + if (mIsBluetoothEnabled) { + if (iBluetoothDeviceManagerCallback != null) { + iBluetoothDeviceManagerCallback.onBluetoothDeviceTurningOff(); + } + } + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/IBluetoothDeviceManager.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/IBluetoothDeviceManager.java new file mode 100644 index 000000000..f2109033d --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/IBluetoothDeviceManager.java @@ -0,0 +1,12 @@ +package com.ford.syncV4.android.manager; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 12/26/13 + * Time: 6:00 PM + */ +public interface IBluetoothDeviceManager { + void onBluetoothDeviceRestoreConnection(); + void onBluetoothDeviceTurningOff(); +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/LastUsedHashIdsManager.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/LastUsedHashIdsManager.java new file mode 100644 index 000000000..7d3126fdf --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/LastUsedHashIdsManager.java @@ -0,0 +1,70 @@ +package com.ford.syncV4.android.manager; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 2/28/14 + * Time: 1:30 PM + */ + +import java.util.LinkedList; + +/** + * This class provides functionality to manage last used + * {@link com.ford.syncV4.proxy.rpc.RegisterAppInterface#getHashID()} collection + */ +public class LastUsedHashIdsManager { + + public static final int LAST_USED_IDS_NUMBER = 5; + + private static final String TAG = "LastUsedHashIdsManager"; + + private LinkedList<String> mLastUsedHashIds = new LinkedList<String>(); + + /** + * Read collection from the Preferences + */ + public void init() { + String lastUsedHashIds = AppPreferencesManager.getLastUsedHashIds(); + String[] strings = lastUsedHashIds.split(","); + for (String string : strings) { + mLastUsedHashIds.addLast(string); + } + } + + /** + * Save collection to the Preferences + */ + public void save() { + StringBuilder stringBuilder = new StringBuilder(); + for (String mLastUsedHashId : mLastUsedHashIds) { + stringBuilder.append(mLastUsedHashId); + stringBuilder.append(","); + } + stringBuilder.delete(stringBuilder.length() - 1, stringBuilder.length()); + AppPreferencesManager.setLastUsedHashIds(stringBuilder.toString()); + } + + /** + * Add new Hash Id to the collection. If the size of the collection will be greater then + * {@code LAST_USED_IDS_NUMBER}, all other elements will be removed + * + * @param value Hash Id + */ + public void addNewId(String value) { + while (mLastUsedHashIds.size() >= LAST_USED_IDS_NUMBER) { + mLastUsedHashIds.pollLast(); + } + mLastUsedHashIds.addFirst(value); + } + + /** + * Return {@link java.lang.String} array of the hash id's + * + * @return array of the hash id's + */ + public String[] getDataForAdapter() { + String[] strings = new String[mLastUsedHashIds.size()]; + return mLastUsedHashIds.toArray(strings); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/PutFileTransferManager.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/PutFileTransferManager.java new file mode 100644 index 000000000..3b26be6fc --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/PutFileTransferManager.java @@ -0,0 +1,100 @@ +package com.ford.syncV4.android.manager; + +import android.util.SparseArray; + +import com.ford.syncV4.proxy.rpc.PutFile; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 1/30/14 + * Time: 4:30 PM + */ + +/** + * This class manage a procedure of transfer PutFile. There is a possibility keep reference for + * the PutFile which is going to be transmitted in the array, then, upon transfer success, there is + * a possibility to remove reference from array. There are also additional helper methods which + * allow to manage array of the PutFiles. This class IS NOT thread safe! + */ +public class PutFileTransferManager { + + // A map to track PutFiles which are send successfully + private SparseArray<PutFile> mPutFilesArray; + + public PutFileTransferManager() { + mPutFilesArray = new SparseArray<PutFile>(); + } + + /** + * Keep PutFile in the array + * + * @param correlationId unique identifier of the PutFile object + * @param putFile PutFile object to store in array + */ + public void addPutFileToAwaitArray(int correlationId, PutFile putFile) { + mPutFilesArray.put(correlationId, putFile); + } + + /** + * Remove PutFile from the array + * @param correlationId unique identifier of the PutFile object + */ + public void removePutFileFromAwaitArray(int correlationId) { + PutFile putFile = mPutFilesArray.get(correlationId); + if (putFile != null) { + + // Not sure if this technique will actually null an Object + addPutFileToAwaitArray(correlationId, null); + + mPutFilesArray.delete(correlationId); + } + } + + /** + * Checks whether a PutFile with given unique identifier exists in the array + * @param correlationId unique identifier of the PutFile object + * @return true if PutFile with such correlationId exists, false in any other case + */ + public boolean hasPutFileInAwaitArray(int correlationId) { + return mPutFilesArray != null && mPutFilesArray.get(correlationId) != null; + } + + /** + * Return and remove next available PutFile object from array + * @return PutFile object if such exists or null if array is empty + */ + public PutFile getNextPutFile() { + if (mPutFilesArray.size() == 0) { + return null; + } + PutFile putFile = mPutFilesArray.get(mPutFilesArray.size() - 1); + mPutFilesArray.delete(mPutFilesArray.size() - 1); + return putFile; + } + + /** + * Check if there are any PutFiles in array + * @return true if there are PutFiles in array, false if array is empty + */ + public boolean hasNext() { + return mPutFilesArray != null && mPutFilesArray.size() > 0; + } + + /** + * Return a copy of the array + * @return a copy of the array + */ + public SparseArray<PutFile> getCopy() { + return mPutFilesArray.clone(); + } + + /** + * Clear the existed array of PutFiles + */ + public void clear() { + if (mPutFilesArray != null) { + mPutFilesArray.clear(); + } + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/RPCRequestsResumableManager.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/RPCRequestsResumableManager.java new file mode 100644 index 000000000..c204b6f18 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/manager/RPCRequestsResumableManager.java @@ -0,0 +1,165 @@ +package com.ford.syncV4.android.manager; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 2/26/14 + * Time: 12:25 PM + */ + +import com.ford.syncV4.exception.SyncException; +import com.ford.syncV4.proxy.RPCRequest; +import com.ford.syncV4.proxy.rpc.PutFile; + +import java.util.Vector; + +/** + * This class provide functionality to manage RPC Requests which are involved in application + * resumption procedure + */ +public class RPCRequestsResumableManager { + + public interface RPCRequestsResumableManagerCallback { + public void onSendRequest(RPCRequest request); + } + + // This Vector keep all RPC requests since the last successful application start in case of + // connection exists + private final Vector<RPCRequest> rpcRequestsResumableConnected = new Vector<RPCRequest>(); + // This Vector keep all RPC requests since the last successful application start in case of + // connection does not exists + private final Vector<RPCRequest> rpcRequestsResumableDisconnected = new Vector<RPCRequest>(); + + // This Vector keep all PutFiles since the last successful application start + //private final Vector<PutFile> putFiles = new Vector<PutFile>(); + + private RPCRequestsResumableManagerCallback callback; + + /** + * Constructor + */ + public RPCRequestsResumableManager() { + + } + + /** + * Set callback handler to inform about outgoing requests + * + * @param callback {@link com.ford.syncV4.android.manager.RPCRequestsResumableManager.RPCRequestsResumableManagerCallback} + */ + public void setCallback(RPCRequestsResumableManagerCallback callback) { + this.callback = callback; + } + + /** + * Add RPC request to the collection in case of connection exists + * + * @param request {@link com.ford.syncV4.proxy.RPCRequest} object + */ + public void addRequestConnected(RPCRequest request) { + rpcRequestsResumableConnected.add(request); + } + + /** + * Add RPC request to the collection in case of connection does not exists + * + * @param request {@link com.ford.syncV4.proxy.RPCRequest} object + */ + public void addRequestDisconnected(RPCRequest request) { + rpcRequestsResumableDisconnected.add(request); + } + + /** + * Add {@link com.ford.syncV4.proxy.rpc.PutFile} request to the collection + * + * @param putFile {@link com.ford.syncV4.proxy.rpc.PutFile} request + */ + /*public void addPutFile(PutFile putFile) { + putFiles.add(putFile); + }*/ + + /** + * Send all RPC requests which were add when there were connection to SDL. + * + * @throws SyncException + */ + public void sendAllRequestsConnected() throws SyncException { + for (RPCRequest request : rpcRequestsResumableConnected) { + if (callback != null) { + callback.onSendRequest(request); + } + } + } + + /** + * Send all RPC requests which were add when there were no connection to SDL. + * + * @throws SyncException + */ + public void sendAllRequestsDisconnected() throws SyncException { + for (RPCRequest request : rpcRequestsResumableDisconnected) { + if (callback != null) { + callback.onSendRequest(request); + } + } + } + + /** + * Send all RPC requests which were add since last success connection + * + * @throws SyncException + */ + /*public void sendAllPutFiles() throws SyncException { + for (PutFile putFile : putFiles) { + if (callback != null) { + callback.onSendRequest(putFile); + } + } + }*/ + + /** + * Clean all RPC requests which were add when there were connection to SDL. + */ + public void cleanAllRequestsDisconnected() { + rpcRequestsResumableDisconnected.clear(); + } + + /** + * Clean all {@link com.ford.syncV4.proxy.rpc.PutFile}'s requests collection + */ + /*public void cleanAllPutFiles() { + putFiles.clear(); + }*/ + + /** + * Clean all RPC requests which were add when there were no connection to SDL. + */ + public void cleanAllRequestsConnected() { + rpcRequestsResumableConnected.clear(); + } + + /** + * Return a size of the RPC requests collection + * + * @return a size of the collection + */ + public int getRequestsConnectedSize() { + return rpcRequestsResumableConnected.size(); + } + + /** + * Return a size of the RPC requests collection + * + * @return a size of the collection + */ + public int getRequestsDisconnectedSize() { + return rpcRequestsResumableDisconnected.size(); + } + + /** + * @return a size of the {@link com.ford.syncV4.proxy.rpc.PutFile}'s requests collection + */ + /*public int getPutFilesSize() { + return putFiles.size(); + }*/ +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/marshaller/CustomJsonRPCMarshaller.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/marshaller/CustomJsonRPCMarshaller.java new file mode 100644 index 000000000..b76395077 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/marshaller/CustomJsonRPCMarshaller.java @@ -0,0 +1,39 @@ +package com.ford.syncV4.android.marshaller; + +import java.util.Hashtable; + +import com.ford.syncV4.marshal.IJsonRPCMarshaller; +import com.ford.syncV4.proxy.RPCMessage; + +/** + * A special-case marshaller that will return the same stubbed bytes to respond + * to any incoming message. Note that you shouldn't use the unmarshalling here + * (for that case, it throws a RuntimeException). + */ +public class CustomJsonRPCMarshaller implements IJsonRPCMarshaller { + /** The string that the marshaller will return for any incoming message. */ + private String stubbedValue = null; + + public CustomJsonRPCMarshaller(String stubbedValue) { + this.stubbedValue = stubbedValue; + } + + @Override + public byte[] marshall(RPCMessage msg, byte version) { + return stubbedValue.getBytes(); + } + + @Override + public Hashtable<String, Object> unmarshall(byte[] message) { + throw new RuntimeException( + "Custom JSON marshaller should only be used to marshall messages"); + } + + public String getStubbedValue() { + return stubbedValue; + } + + public void setStubbedValue(String stubbedValue) { + this.stubbedValue = stubbedValue; + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/marshaller/InvalidJsonRPCMarshaller.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/marshaller/InvalidJsonRPCMarshaller.java new file mode 100644 index 000000000..760060091 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/marshaller/InvalidJsonRPCMarshaller.java @@ -0,0 +1,27 @@ +package com.ford.syncV4.android.marshaller; + +import com.ford.syncV4.marshal.JsonRPCMarshaller; +import com.ford.syncV4.proxy.RPCMessage; + +/** + * Wraps {@link JsonRPCMarshaller} to produce an invalid marshalled JSON + * message. + */ +public class InvalidJsonRPCMarshaller extends JsonRPCMarshaller { + + private static final String TAG = InvalidJsonRPCMarshaller.class.getSimpleName(); + + @Override + public byte[] marshall(RPCMessage msg, byte version) { + byte[] msgBytes = super.marshall(msg, version); + + if (msgBytes != null) { + final int newLength = msgBytes.length - 1; + byte[] bytes = new byte[newLength]; + System.arraycopy(msgBytes, 0, bytes, 0, newLength); + return bytes; + } else { + return null; + } + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/GenericRequest.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/GenericRequest.java new file mode 100644 index 000000000..008898952 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/GenericRequest.java @@ -0,0 +1,22 @@ +package com.ford.syncV4.android.module; + +import com.ford.syncV4.proxy.RPCRequest; + +import java.util.Hashtable; + +/** + * A custom {@link com.ford.syncV4.proxy.RPCRequest} subclass that is not + * present in the specification. Used to test that the response is + * {@link com.ford.syncV4.proxy.rpc.GenericResponse}. + */ +public class GenericRequest extends RPCRequest { + public static final String NAME = GenericRequest.class.getSimpleName(); + + public GenericRequest() { + super(NAME); + } + + public GenericRequest(Hashtable hash) { + super(hash); + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/ModuleTest.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/ModuleTest.java new file mode 100644 index 000000000..c706cde14 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/ModuleTest.java @@ -0,0 +1,1159 @@ +package com.ford.syncV4.android.module; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileWriter; +import java.io.FilenameFilter; +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Hashtable; +import java.util.Iterator; +import java.util.List; +import java.util.Vector; + +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +import android.app.AlertDialog; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.net.Uri; +import android.os.PowerManager; +import android.os.PowerManager.WakeLock; +import android.util.Log; +import android.util.Pair; +import android.util.Xml; + +import com.ford.syncV4.android.activity.SyncProxyTester; +import com.ford.syncV4.android.adapters.LogAdapter; +import com.ford.syncV4.android.constants.AcceptedRPC; +import com.ford.syncV4.android.marshaller.CustomJsonRPCMarshaller; +import com.ford.syncV4.android.marshaller.InvalidJsonRPCMarshaller; +import com.ford.syncV4.android.module.reader.BinaryDataReader; +import com.ford.syncV4.android.module.reader.BinaryDataReaderFactory; +import com.ford.syncV4.android.service.ProxyService; +import com.ford.syncV4.marshal.IJsonRPCMarshaller; +import com.ford.syncV4.proxy.RPCRequest; +import com.ford.syncV4.proxy.RPCRequestFactory; +import com.ford.syncV4.proxy.RPCStruct; +import com.ford.syncV4.proxy.constants.Names; +import com.ford.syncV4.proxy.rpc.Alert; +import com.ford.syncV4.proxy.rpc.AlertManeuver; +import com.ford.syncV4.proxy.rpc.ChangeRegistration; +import com.ford.syncV4.proxy.rpc.DeleteCommand; +import com.ford.syncV4.proxy.rpc.DeleteFile; +import com.ford.syncV4.proxy.rpc.DeleteInteractionChoiceSet; +import com.ford.syncV4.proxy.rpc.DeleteSubMenu; +import com.ford.syncV4.proxy.rpc.EncodedSyncPData; +import com.ford.syncV4.proxy.rpc.EndAudioPassThru; +import com.ford.syncV4.proxy.rpc.GetDTCs; +import com.ford.syncV4.proxy.rpc.GetVehicleData; +import com.ford.syncV4.proxy.rpc.ListFiles; +import com.ford.syncV4.proxy.rpc.PerformAudioPassThru; +import com.ford.syncV4.proxy.rpc.PerformInteraction; +import com.ford.syncV4.proxy.rpc.ReadDID; +import com.ford.syncV4.proxy.rpc.RegisterAppInterface; +import com.ford.syncV4.proxy.rpc.ResetGlobalProperties; +import com.ford.syncV4.proxy.rpc.ScrollableMessage; +import com.ford.syncV4.proxy.rpc.SetAppIcon; +import com.ford.syncV4.proxy.rpc.SetDisplayLayout; +import com.ford.syncV4.proxy.rpc.SetMediaClockTimer; +import com.ford.syncV4.proxy.rpc.Show; +import com.ford.syncV4.proxy.rpc.ShowConstantTBT; +import com.ford.syncV4.proxy.rpc.Slider; +import com.ford.syncV4.proxy.rpc.Speak; +import com.ford.syncV4.proxy.rpc.StartTime; +import com.ford.syncV4.proxy.rpc.SubscribeVehicleData; +import com.ford.syncV4.proxy.rpc.SyncPData; +import com.ford.syncV4.proxy.rpc.UnregisterAppInterface; +import com.ford.syncV4.proxy.rpc.UnsubscribeButton; +import com.ford.syncV4.proxy.rpc.UnsubscribeVehicleData; +import com.ford.syncV4.proxy.rpc.UpdateTurnList; +import com.ford.syncV4.proxy.rpc.enums.Result; +import com.ford.syncV4.proxy.rpc.enums.UpdateMode; + +public class ModuleTest { + /** + * Wraps the {@link RPCRequest} class to add some extra fields (pause after + * the request; whether to generate invalid JSON; custom JSON to set in + * request). + */ + class RPCRequestWrapper { + private RPCRequest request = null; + private long pause = 0; + private boolean generateInvalidJSON = false; + private String customJSON = null; + + public RPCRequestWrapper(RPCRequest request, long pause, + boolean generateInvalidJSON) { + this(request, pause, generateInvalidJSON, null); + } + + public RPCRequestWrapper(RPCRequest request, long pause, + boolean generateInvalidJSON, String customJSON) { + this.request = request; + this.pause = pause; + this.generateInvalidJSON = generateInvalidJSON; + this.customJSON = customJSON; + } + + public long getPause() { + return pause; + } + + public void setPause(long pause) { + this.pause = pause; + } + + public RPCRequest getRequest() { + return request; + } + + public boolean isGenerateInvalidJSON() { + return generateInvalidJSON; + } + + public void setGenerateInvalidJSON(boolean generateInvalidJSON) { + this.generateInvalidJSON = generateInvalidJSON; + } + + public String getCustomJSON() { + return customJSON; + } + + public void setCustomJSON(String customJSON) { + this.customJSON = customJSON; + } + } + + /** Represents a test as read from the test file. */ + class Test { + private String name = null; + private long pause = 0; + private List<RPCRequestWrapper> requests = null; + + public Test() { + super(); + } + + public Test(String name, long pause, List<RPCRequestWrapper> requests) { + this.name = name; + this.pause = pause; + this.requests = requests; + } + + /** + * Adds the specified request to the list. If the list is null, it's + * created first. + * + * @param request request to add + */ + public void addRequest(RPCRequestWrapper request) { + if (requests == null) { + requests = new ArrayList<ModuleTest.RPCRequestWrapper>(); + } + + requests.add(request); + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public long getPause() { + return pause; + } + + public void setPause(long pause) { + this.pause = pause; + } + + public List<RPCRequestWrapper> getRequests() { + return requests; + } + + public void setRequests(List<RPCRequestWrapper> requests) { + this.requests = requests; + } + } + + /** Log tag for the class. */ + private static final String TAG = ModuleTest.class.getSimpleName(); + /** Specifies whether to display debug info from the XML parser. */ + private static final boolean DISPLAY_PARSER_DEBUG_INFO = false; + /** Extension of supported test files. */ + private static final String TEST_FILEEXT = ".xml"; + + /** + * The tag name used to specify where to get binary data from (e.g., for + * PutFile message). + */ + private final static String BINARY_TAG_NAME = "Binary"; + /** Tag name for float numbers. */ + private static final String TAG_FLOAT = "Float"; + /** + * Attribute name for binary data, because it requires special handling when + * creating certain messages (e.g. calling PutFile's + * {@link RPCStruct#setBulkData(byte[])} method). + */ + private final static String BULK_DATA_ATTR = "bulkData"; + /** Attribute name that defines the test's name in a <test> tag. */ + private final static String TEST_NAME_ATTR = "testName"; + /** Attribute name that defines the timeout of a <test> or a request. */ + private final static String PAUSE_ATTR = "pause"; + /** + * Attribute name that defines if the generated request's JSON should be + * invalid. + */ + private final static String INVALID_JSON_ATTR = "invalidJSON"; + /** Attribute name that defines custom JSON of the request. */ + private final static String CUSTOM_JSON_ATTR = "customJSON"; + /** Attribute name of request's correlation ID. */ + private final static String CORRELATION_ID_ATTR = "correlationID"; + + private static ModuleTest _instance; + private SyncProxyTester mActivityInstance; + private LogAdapter mLogAdapter; + private static Runnable threadContext; + private static ModuleTest DialogThreadContext; + private Thread mainThread; + + private boolean pass; + private boolean integration; + private String userPrompt; + + private int numIterations; + + private ArrayList<Pair<Integer, Result>> expecting = new ArrayList<Pair<Integer, Result>>(); + private Test currentTest = null; + + public static ArrayList<Pair<Integer, Result>> responses = new ArrayList<Pair<Integer, Result>>(); + + /** Factory that is used to return a reader for the binary data in tests. */ + private BinaryDataReaderFactory binaryDataReaderFactory = new BinaryDataReaderFactory(); + + /** WakeLock to keep screen on while testing. */ + private WakeLock wakeLock = null; + + /** Full path to XML test file or directory with test files. */ + private String mFilePath; + + private ProxyService mProxyService; + + // TODO : Reconsider! + public ModuleTest(ProxyService proxyService, LogAdapter logAdapter) { + mProxyService = proxyService; + mActivityInstance = SyncProxyTester.getInstance(); + mLogAdapter = logAdapter; + + // Set this's instance + _instance = this; + mActivityInstance.setTesterMain(_instance); + + mainThread = makeThread(); + } + + /** + * Starts the thread for xml thread. + * + * @param filePath + * path to XML test file or directory with XML test files to use. + */ + public void runTests(String filePath) { + this.mFilePath = filePath; + mainThread.start(); + } + + /** + * Recreates and starts a new thread for xml testing. + * + * @param filePath + * path to XML test file or directory with XML test files to use. + * Pass null to use the previously set value. + */ + public void restart(String filePath) { + mainThread.interrupt(); + mainThread = null; + if (filePath != null) { + this.mFilePath = filePath; + } + mainThread = makeThread(); + mainThread.start(); + } + + public Thread makeThread () { + return new Thread(new Runnable() { + public void run() { + if (mFilePath != null) { + // if the file path is a directory, find all xmls in it + File file = new File(mFilePath); + if (file.isDirectory()) { + String[] filenames = file.list(new FilenameFilter() { + @Override + public boolean accept(File dir, String filename) { + return filename.endsWith(TEST_FILEEXT); + } + }); + if (filenames != null) { + Arrays.sort(filenames); + + if (filenames.length > 0) { + List<String> paths = new ArrayList<String>(); + for (String filename : filenames) { + mLogAdapter.logMessage("Processing " + + filename, Log.INFO, true); + try { + String fullPath = mFilePath + File.separator + filename; + processTestFile(fullPath); + paths.add(getTestResultsFilename(fullPath)); + String testErrorsFilename = getTestErrorsFilename(fullPath); + if (!fileIsEmpty(testErrorsFilename)) { + paths.add(testErrorsFilename); + } + } catch (Exception e) { + mLogAdapter + .logMessage("Parser Failed!!", + Log.ERROR, e); + } + } + mLogAdapter.logMessage("All tests finished", + Log.INFO, true); + + if (paths.size() > 0) { + sendReportEmail(paths); + } + } else { + mLogAdapter.logMessage( + "No test files found in " + mFilePath, + Log.INFO, true); + } + } else { + mLogAdapter.logMessage( + "Couldn't list files in directory", + Log.ERROR, true); + } + } else { + try { + processTestFile(mFilePath); + + List<String> paths = new ArrayList<String>(); + paths.add(getTestResultsFilename(mFilePath)); + String testErrorsFilename = getTestErrorsFilename(mFilePath); + if (!fileIsEmpty(testErrorsFilename)) { + paths.add(testErrorsFilename); + } + sendReportEmail(paths); + } catch (Exception e) { + mLogAdapter.logMessage("Parser Failed!!", + Log.ERROR, e); + } + } + } else { + Log.w(TAG, "No file chosen"); + } + } + + private void sendReportEmail(List<String> filePaths) { + // http://stackoverflow.com/questions/2264622/android-multiple-email-attachments-using-intent/3300495#3300495 + if (filePaths != null) { + final int numFilePaths = filePaths.size(); + + Intent email = new Intent( + numFilePaths > 1 ? Intent.ACTION_SEND_MULTIPLE + : Intent.ACTION_SEND); + email.setType("text/plain"); + email.putExtra(Intent.EXTRA_EMAIL, + new String[] { "youremail@ford.com" }); + email.putExtra(Intent.EXTRA_SUBJECT, "Lua Unit Test Export"); + + switch (numFilePaths) { + case 0: + // no attachments + break; + + case 1: + email.putExtra(Intent.EXTRA_STREAM, + Uri.fromFile(new File(filePaths.get(0)))); + break; + + default: + // assuming there can't be negative array size + ArrayList<Uri> uris = new ArrayList<Uri>(numFilePaths); + for (String filePath : filePaths) { + uris.add(Uri.fromFile(new File(filePath))); + } + email.putParcelableArrayListExtra(Intent.EXTRA_STREAM, + uris); + break; + } + + mActivityInstance.startActivity(Intent.createChooser(email, + "Choose an Email client :")); + } + } + + private void processTestFile(String filename) throws IOException, + XmlPullParserException { + AcceptedRPC acceptedRPC = new AcceptedRPC(); + XmlPullParser parser = Xml.newPullParser(); + RPCRequest rpc; + try { + if (mActivityInstance.getDisableLockFlag()) { + acquireWakeLock(); + } + + FileInputStream fin = new FileInputStream(filename); + InputStreamReader isr = new InputStreamReader(fin); + + // file writer for test results + String outFile = getTestResultsFilename(filename); + File out = new File(outFile); + FileWriter writer = new FileWriter(out); + writer.flush(); + + // file writer for test errors + String outErrorFile = getTestErrorsFilename(filename); + File outError = new File(outErrorFile); + FileWriter errorWriter = new FileWriter(outError); + errorWriter.flush(); + + parser.setInput(isr); + int eventType = parser.getEventType(); + String name; + boolean done = false; + while (eventType != XmlPullParser.END_DOCUMENT && !done) { + name = parser.getName(); + + switch (eventType) { + case XmlPullParser.START_DOCUMENT: + logParserDebugInfo("START_DOCUMENT, name: " + name); + break; + case XmlPullParser.END_DOCUMENT: + logParserDebugInfo("END_DOCUMENT, name: " + name); + break; + case XmlPullParser.START_TAG: + name = parser.getName(); + if (name.equalsIgnoreCase("test")) { + mLogAdapter.logMessage("test " + parser.getAttributeValue(0), true); + + long pause = 0; + String pauseString = parser.getAttributeValue(null, PAUSE_ATTR); + if (pauseString != null) { + try { + pause = Long.parseLong(pauseString); + } catch (NumberFormatException e) { + Log.e(TAG, "Couldn't parse pause number: " + pauseString); + } + } + currentTest = new Test(parser.getAttributeValue(null, TEST_NAME_ATTR), + pause, null); + expecting.clear(); + responses.clear(); + try { + if (parser.getAttributeName(1) != null) { + if (parser.getAttributeName(1).equalsIgnoreCase("iterations")) { + try {numIterations = Integer.parseInt(parser.getAttributeValue(1));} + catch (Exception e) {Log.e(TAG, "Unable to parse number of iterations");} + } else numIterations = 1; + } else numIterations = 1; + } catch (Exception e) { + numIterations = 1; + } + } else if (name.equalsIgnoreCase("type")) { + if (parser.getAttributeValue(0).equalsIgnoreCase("integration")) integration = true; + else if (parser.getAttributeValue(0).equalsIgnoreCase("unit")) integration = false; + } else if (acceptedRPC.isAcceptedRPC(name)) { + //Create correct object + if (name.equalsIgnoreCase(Names.RegisterAppInterface)) { + rpc = new RegisterAppInterface(); + } else if (name.equalsIgnoreCase(Names.UnregisterAppInterface)) { + rpc = new UnregisterAppInterface(); + } else if (name.equalsIgnoreCase(Names.SetGlobalProperties)) { + rpc = RPCRequestFactory.buildSetGlobalProperties(); + } else if (name.equalsIgnoreCase(Names.ResetGlobalProperties)) { + rpc = new ResetGlobalProperties(); + } else if (name.equalsIgnoreCase(Names.AddCommand)) { + rpc = RPCRequestFactory.buildAddCommand(); + } else if (name.equalsIgnoreCase(Names.DeleteCommand)) { + rpc = new DeleteCommand(); + } else if (name.equalsIgnoreCase(Names.AddSubMenu)) { + rpc = RPCRequestFactory.buildAddSubMenu(); + } else if (name.equalsIgnoreCase(Names.DeleteSubMenu)) { + rpc = new DeleteSubMenu(); + } else if (name.equalsIgnoreCase(Names.CreateInteractionChoiceSet)) { + rpc = RPCRequestFactory.buildCreateInteractionChoiceSet(); + } else if (name.equalsIgnoreCase(Names.PerformInteraction)) { + rpc = new PerformInteraction(); + } else if (name.equalsIgnoreCase(Names.DeleteInteractionChoiceSet)) { + rpc = new DeleteInteractionChoiceSet(); + } else if (name.equalsIgnoreCase(Names.Alert)) { + rpc = new Alert(); + } else if (name.equalsIgnoreCase(Names.Show)) { + rpc = new Show(); + } else if (name.equalsIgnoreCase(Names.Speak)) { + rpc = new Speak(); + } else if (name.equalsIgnoreCase(Names.SetMediaClockTimer)) { + rpc = new SetMediaClockTimer(); + } else if (name.equalsIgnoreCase(Names.EncodedSyncPData)) { + rpc = new EncodedSyncPData(); + } else if (name.equalsIgnoreCase(Names.SyncPData)) { + rpc = new SyncPData(); + } else if (name.equalsIgnoreCase(Names.PerformAudioPassThru)) { + rpc = new PerformAudioPassThru(); + } else if (name.equalsIgnoreCase(Names.EndAudioPassThru)) { + rpc = new EndAudioPassThru(); + } else if (name.equalsIgnoreCase(Names.SubscribeButton)) { + rpc = RPCRequestFactory.buildSubscribeButton(); + } else if (name.equalsIgnoreCase(Names.UnsubscribeButton)) { + rpc = new UnsubscribeButton(); + } else if (name.equalsIgnoreCase(Names.SubscribeVehicleData)) { + rpc = RPCRequestFactory.buildSubscribeVehicleData(); + } else if (name.equalsIgnoreCase(Names.UnsubscribeVehicleData)) { + rpc = new UnsubscribeVehicleData(); + } else if (name.equalsIgnoreCase(Names.GetVehicleData)) { + rpc = new GetVehicleData(); + } else if (name.equalsIgnoreCase(Names.ReadDID)) { + rpc = new ReadDID(); + } else if (name.equalsIgnoreCase(Names.GetDTCs)) { + rpc = new GetDTCs(); + } else if (name.equalsIgnoreCase(Names.ScrollableMessage)) { + rpc = new ScrollableMessage(); + } else if (name.equalsIgnoreCase(Names.Slider)) { + rpc = new Slider(); + } else if (name.equalsIgnoreCase(Names.ShowConstantTBT)) { + rpc = new ShowConstantTBT(); + } else if (name.equalsIgnoreCase(Names.AlertManeuver)) { + rpc = new AlertManeuver(); + } else if (name.equalsIgnoreCase(Names.UpdateTurnList)) { + rpc = new UpdateTurnList(); + } else if (name.equalsIgnoreCase(Names.ChangeRegistration)) { + rpc = new ChangeRegistration(); + } else if (name.equalsIgnoreCase(Names.PutFile)) { + rpc = RPCRequestFactory.buildPutFile(); + } else if (name.equalsIgnoreCase(Names.DeleteFile)) { + rpc = new DeleteFile(); + } else if (name.equalsIgnoreCase(Names.ListFiles)) { + rpc = new ListFiles(); + } else if (name.equalsIgnoreCase(Names.SetAppIcon)) { + rpc = new SetAppIcon(); + } else if (name.equalsIgnoreCase(Names.SetDisplayLayout)) { + rpc = new SetDisplayLayout(); + } else if (name.equalsIgnoreCase("ClearMediaClockTimer")) { + rpc = new Show(); + ((Show) rpc).setMainField1(null); + ((Show) rpc).setMainField2(null); + ((Show) rpc).setStatusBar(null); + ((Show) rpc).setMediaClock(" "); + ((Show) rpc).setMediaTrack(null); + ((Show) rpc).setAlignment(null); + } else if (name.equalsIgnoreCase("PauseMediaClockTimer")) { + rpc = new SetMediaClockTimer(); + StartTime startTime = new StartTime(); + startTime.setHours(0); + startTime.setMinutes(0); + startTime.setSeconds(0); + ((SetMediaClockTimer) rpc).setStartTime(startTime); + ((SetMediaClockTimer) rpc).setUpdateMode(UpdateMode.PAUSE); + } else if (name.equalsIgnoreCase("ResumeMediaClockTimer")) { + rpc = new SetMediaClockTimer(); + StartTime startTime = new StartTime(); + startTime.setHours(0); + startTime.setMinutes(0); + startTime.setSeconds(0); + ((SetMediaClockTimer) rpc).setStartTime(startTime); + ((SetMediaClockTimer) rpc).setUpdateMode(UpdateMode.RESUME); + } else if (name.equalsIgnoreCase(GenericRequest.NAME)) { + rpc = new GenericRequest(); + } else { + rpc = RPCRequestFactory.buildSetGlobalProperties(); + } + + try { + rpc.setCorrelationID(Integer.parseInt(parser.getAttributeValue(null, CORRELATION_ID_ATTR))); + } catch (NumberFormatException e) { + Log.e(TAG, "Unable to parse correlation ID"); + } + + long pause = 0; + String pauseString = parser.getAttributeValue(null, PAUSE_ATTR); + if (pauseString != null) { + try { + pause = Long.parseLong(pauseString); + } catch (NumberFormatException e) { + Log.e(TAG, "Couldn't parse pause number: " + pauseString); + } + } + + boolean generateInvalidJSON = (parser.getAttributeValue(null, INVALID_JSON_ATTR) + != null); + + String customJSON = parser.getAttributeValue(null, CUSTOM_JSON_ATTR); + + //TODO: Set rpc parameters + Hashtable hash = setParams(name, parser); + logParserDebugInfo("" + hash); + //TODO: Iterate through hash table and add it to parameters + for (Object key : hash.keySet()) { + final Object value = hash.get(key); + if (((String) key).equals(BULK_DATA_ATTR)) { + if (value instanceof byte[]) { + rpc.setBulkData((byte[]) value); + } else { + rpc.setBulkData(new byte[]{ }); + } + } else { + rpc.setParameters((String) key, value); + } + } + + Iterator it = hash.entrySet().iterator(); + while (it.hasNext()) { + Hashtable.Entry pairs = (Hashtable.Entry)it.next(); + logParserDebugInfo(pairs.getKey() + " = " + pairs.getValue()); + } + + if (currentTest != null) { + RPCRequestWrapper wrapper = new RPCRequestWrapper(rpc, pause, + generateInvalidJSON, customJSON); + currentTest.addRequest(wrapper); + } + } else if (name.equalsIgnoreCase("result")) { + expecting.add(new Pair<Integer, Result>(Integer.parseInt(parser.getAttributeValue(0)), (Result.valueForString(parser.getAttributeValue(1))))); + } else if (name.equalsIgnoreCase("userPrompt") && integration) { + userPrompt = parser.getAttributeValue(0); + } + break; + case XmlPullParser.END_TAG: + name = parser.getName(); + if (name.equalsIgnoreCase("test")) { + try { + final String FIELD_SEPARATOR = ", "; + final String EOL = "\n"; + + boolean localPass = true; + int i = numIterations; + int numPass = 0; + while (i > 0) { + xmlTest(); + if (pass) { + numPass++; + } else { + localPass = false; + StringBuilder errorBuilder = new StringBuilder(currentTest.getName()); + errorBuilder.append(" Expected"); + for (Pair p : expecting) { + errorBuilder.append(FIELD_SEPARATOR); + errorBuilder.append(p.first); + errorBuilder.append(" "); + errorBuilder.append(p.second); + } + errorBuilder.append(EOL); + + errorBuilder.append(currentTest.getName()); + errorBuilder.append(" Actual"); + for (Pair p : responses) { + errorBuilder.append(FIELD_SEPARATOR); + errorBuilder.append(p.first); + errorBuilder.append(" "); + errorBuilder.append(p.second); + } + errorBuilder.append(EOL); + + String errorLine = errorBuilder.toString(); + errorWriter.write(errorLine); + } + i--; + } + + if (currentTest != null) { + StringBuilder result = new StringBuilder(currentTest.getName()); + String[] fields = { (localPass ? "Pass" : "Fail"), String.valueOf(numPass), String.valueOf(numIterations) }; + for (String field : fields) { + result.append(FIELD_SEPARATOR); + result.append(field); + } + String resultLine = result.toString(); + + writer.write(resultLine + EOL); + Log.i(TAG, resultLine); + mLogAdapter.logMessage(resultLine, true); + } + } catch (Exception e) { + if (currentTest != null) { + mLogAdapter.logMessage("Test " + currentTest.getName() + " Failed! ", Log.ERROR, e); + } + } + } + break; + case XmlPullParser.TEXT: + //logParserDebugInfo("TEXT, name: " + name); + break; + case XmlPullParser.CDSECT: + logParserDebugInfo("CDSECT, name: " + name); + break; + case XmlPullParser.ENTITY_REF: + logParserDebugInfo("ENTITY_REF, name: " + name); + break; + case XmlPullParser.IGNORABLE_WHITESPACE: + logParserDebugInfo("IGNORABLE_WHITESPACE, name: " + name); + break; + case XmlPullParser.PROCESSING_INSTRUCTION: + logParserDebugInfo("PROCESSING_INSTRUCTION, name: " + name); + break; + case XmlPullParser.COMMENT: + logParserDebugInfo("COMMENT, name: " + name); + break; + case XmlPullParser.DOCDECL: + logParserDebugInfo("DOCDECL, name: " + name); + break; + default: + break; + } + eventType = parser.next(); + } + writer.close(); + errorWriter.close(); + Log.d(TAG, "Tests finished"); + + currentTest = null; + } finally { + releaseWakeLock(); + } + } + + private String getTestResultsFilename(String filename) { + return filename.substring(0, + filename.length() - TEST_FILEEXT.length()) + + ".csv"; + } + + private String getTestErrorsFilename(String filename) { + return filename.substring(0, + filename.length() - TEST_FILEEXT.length()) + + "Errors.csv"; + } + + private boolean fileIsEmpty(String filename) { + return new File(filename).length() <= 0; + } + + }); + } + + private Hashtable setParams(String name, XmlPullParser parser) { + + logParserDebugInfo("setParams start name: " + name); + + Hashtable hash = new Hashtable(); + + int eventType = 0; + Boolean done = false; + String tempName = null; + String vectorName = null; + + try { + while (eventType != XmlPullParser.END_DOCUMENT && !done) { + tempName = parser.getName(); + + switch (eventType) { + case XmlPullParser.START_DOCUMENT: + logParserDebugInfo("START_DOCUMENT, tempName: " + tempName); + break; + case XmlPullParser.END_DOCUMENT: + logParserDebugInfo("END_DOCUMENT, tempName: " + tempName); + break; + case XmlPullParser.START_TAG: + if (tempName.equalsIgnoreCase("Vector")) { + logParserDebugInfo("In Vector"); + Vector<Object> vector = new Vector<Object>(); + + if (parser.getAttributeName(0) != null) vectorName = parser.getAttributeValue(0); + + Boolean nestedWhileDone = false; + + eventType = parser.next(); + while (eventType != XmlPullParser.START_TAG && !nestedWhileDone) { + if (eventType == XmlPullParser.END_TAG) { + if (parser.getName().equalsIgnoreCase("Vector")) { + Log.e("TESTING", "In Vector Loop, nestedWhileDone == true, END_TAG, name: " + name); + nestedWhileDone = true; + } + } else eventType = parser.next(); + } + + while (eventType != XmlPullParser.END_DOCUMENT && !nestedWhileDone) { + tempName = parser.getName(); + logParserDebugInfo("In Vector Loop, tempName: " + tempName); + + switch (eventType) { + case XmlPullParser.START_DOCUMENT: + logParserDebugInfo("In Vector Loop, START_DOCUMENT, name: " + name); + break; + case XmlPullParser.END_DOCUMENT: + logParserDebugInfo("In Vector Loop, END_DOCUMENT, name: " + name); + break; + case XmlPullParser.START_TAG: + if (tempName.equalsIgnoreCase("Integer")) { + logParserDebugInfo("In Nested Vector Integer"); + if (parser.getAttributeName(0) != null) { + //try {vector.add(Integer.parseInt(parser.getAttributeValue(0)));} + try {vector.add(Double.parseDouble(parser.getAttributeValue(0)));} + catch (Exception e) {Log.e(TAG, "Unable to parse Integer");} + } + } else if (tempName.equalsIgnoreCase("String")) { + logParserDebugInfo("In Nested Vector String"); + if (parser.getAttributeName(0) != null) { + vector.add(parser.getAttributeValue(0)); + } + } else { + vector.add(setParams(tempName, parser)); + } + break; + case XmlPullParser.END_TAG: + logParserDebugInfo("In Vector Loop, END_TAG, name: " + name); + if (tempName.equalsIgnoreCase("Vector")) { + logParserDebugInfo("In Vector Loop, nestedWhileDone == true, END_TAG, name: " + name); + nestedWhileDone = true; + } + break; + case XmlPullParser.TEXT: + //logParserDebugInfo("TEXT, name: " + name); + break; + case XmlPullParser.CDSECT: + logParserDebugInfo("In Vector Loop, CDSECT, name: " + name); + break; + case XmlPullParser.ENTITY_REF: + logParserDebugInfo("In Vector Loop, ENTITY_REF, name: " + name); + break; + case XmlPullParser.IGNORABLE_WHITESPACE: + logParserDebugInfo("In Vector Loop, IGNORABLE_WHITESPACE, name: " + name); + break; + case XmlPullParser.PROCESSING_INSTRUCTION: + logParserDebugInfo("In Vector Loop, PROCESSING_INSTRUCTION, name: " + name); + break; + case XmlPullParser.COMMENT: + logParserDebugInfo("In Vector Loop, COMMENT, name: " + name); + break; + case XmlPullParser.DOCDECL: + logParserDebugInfo("In Vector Loop, DOCDECL, name: " + name); + break; + default: + break; + } + eventType = parser.next(); + } + logParserDebugInfo("out of Vector loop"); + hash.put(vectorName, vector); + } else if (tempName.equalsIgnoreCase("Integer")) { + logParserDebugInfo("In Integer"); + if (parser.getAttributeName(0) != null) { + //try {hash.put(parser.getAttributeName(0), Integer.parseInt(parser.getAttributeValue(0)));} + try {hash.put(parser.getAttributeName(0), Double.parseDouble(parser.getAttributeValue(0)));} + catch (Exception e) {Log.e(TAG, "Unable to parse Integer");} + } + } else if (tempName.equalsIgnoreCase(TAG_FLOAT)) { + logParserDebugInfo("In " + TAG_FLOAT); + if (parser.getAttributeName(0) != null) { + try {hash.put(parser.getAttributeName(0), Double.parseDouble(parser.getAttributeValue(0)));} + catch (Exception e) {Log.e(TAG, "Unable to parse " + TAG_FLOAT);} + } + } else if (tempName.equalsIgnoreCase("Boolean")) { + logParserDebugInfo("In Boolean"); + if (parser.getAttributeName(0) != null) { + if (parser.getAttributeValue(0).equalsIgnoreCase("true")) hash.put(parser.getAttributeName(0), true); + else if (parser.getAttributeValue(0).equalsIgnoreCase("false")) hash.put(parser.getAttributeName(0), false); + } + } else if (tempName.equalsIgnoreCase("String")) { + logParserDebugInfo("In String"); + if (parser.getAttributeName(0) != null) { + hash.put(parser.getAttributeName(0), parser.getAttributeValue(0)); + } + } else if (tempName.equalsIgnoreCase(BINARY_TAG_NAME)) { + logParserDebugInfo("In " + BINARY_TAG_NAME); + String srcData = parser.getAttributeValue(0); + final BinaryDataReader reader = binaryDataReaderFactory + .getReaderForString(srcData); + byte[] data; + if (reader != null) { + data = reader.read(srcData); + } else { + // if reader can't be found, set empty data + data = new byte[]{ }; + } + if (data != null) { + hash.put(BULK_DATA_ATTR, data); + } + } else { + logParserDebugInfo("Returning in else statement"); + //return setParams(tempName, parser); + hash.put(tempName, setParams(tempName, parser)); + } + break; + case XmlPullParser.END_TAG: + if (tempName.equalsIgnoreCase(name)) { + done = true; + } + break; + case XmlPullParser.TEXT: + //logParserDebugInfo("TEXT, tempName: " + tempName); + break; + case XmlPullParser.CDSECT: + logParserDebugInfo("CDSECT, tempName: " + tempName); + break; + case XmlPullParser.ENTITY_REF: + logParserDebugInfo("ENTITY_REF, tempName: " + tempName); + break; + case XmlPullParser.IGNORABLE_WHITESPACE: + logParserDebugInfo("IGNORABLE_WHITESPACE, tempName: " + tempName); + break; + case XmlPullParser.PROCESSING_INSTRUCTION: + logParserDebugInfo("PROCESSING_INSTRUCTION, tempName: " + tempName); + break; + case XmlPullParser.COMMENT: + logParserDebugInfo("COMMENT, tempName: " + tempName); + break; + case XmlPullParser.DOCDECL: + logParserDebugInfo("DOCDECL, tempName: " + tempName); + break; + default: + break; + } + eventType = parser.next(); + } + } catch (Exception e) { + mLogAdapter.logMessage("Parser Failed!!", Log.ERROR, e); + } + + logParserDebugInfo("Returning at end of setParams function"); + return hash; + } + + private Boolean xmlTest() { + pass = false; + + Thread newThread = new Thread(new Runnable() { + public void run () { + if (mProxyService != null && currentTest != null && currentTest.getRequests() != null) { + threadContext = this; + + int numResponses = expecting.size(); + if (numResponses > 0) { + mProxyService.waiting(true); + } + + IJsonRPCMarshaller defaultMarshaller = + mProxyService.syncProxyGetJsonRPCMarshaller(); + IJsonRPCMarshaller invalidMarshaller = new InvalidJsonRPCMarshaller(); + CustomJsonRPCMarshaller customMarshaller = new CustomJsonRPCMarshaller(null); + + for (RPCRequestWrapper wrapper : currentTest.getRequests()) { + RPCRequest rpc = wrapper.getRequest(); + boolean generateInvalidJSON = wrapper.isGenerateInvalidJSON(); + String customJSON = wrapper.getCustomJSON(); + if (customJSON != null) { + customMarshaller.setStubbedValue(customJSON); + } + + mLogAdapter.logMessage(rpc, true); + IJsonRPCMarshaller currentMarshaller = + (customJSON != null) ? customMarshaller : + (generateInvalidJSON ? + invalidMarshaller : + defaultMarshaller); + mProxyService.syncProxySetJsonRPCMarshaller(currentMarshaller); + mProxyService.syncProxySendRPCRequest(rpc); + + // restore the default marshaller + mProxyService.syncProxySetJsonRPCMarshaller(defaultMarshaller); + + long pause = wrapper.getPause(); + if (pause > 0) { + Log.v(TAG, "Pause for " + pause + " ms. after " + + currentTest.getName() + "." + rpc.getFunctionName()); + try { + // delay between requests of one test + synchronized (this) { + this.wait(pause); + } + } catch (InterruptedException e) { + mLogAdapter.logMessage("InterruptedException", true); + } + } else { + Log.i(TAG, + "No pause after " + currentTest.getName() + + "." + rpc.getFunctionName()); + } + } + + long pause = currentTest.getPause(); + if (pause > 0) { + Log.v(TAG, "Pause for " + pause + " ms. after " + currentTest.getName()); + try { + // delay after the test + synchronized (this) { + this.wait(pause); + } + } catch (InterruptedException e) { + mLogAdapter.logMessage("InterruptedException", true); + } + } else { + Log.i(TAG, "No pause after " + currentTest.getName()); + } + + // wait for incoming messages + try { + synchronized (this) { + this.wait(100); + } + } catch (InterruptedException e) { + mLogAdapter.logMessage("InterruptedException", true); + } + + mProxyService.waiting(false); + + if (expecting.equals(responses)) { + pass = true; + if (integration) { + mActivityInstance.runOnUiThread(new Runnable() { + public void run() { + AlertDialog.Builder alert = + new AlertDialog.Builder(mActivityInstance); + alert.setMessage(userPrompt); + alert.setPositiveButton("Yes", + new DialogInterface.OnClickListener() { + @Override + public void onClick( + DialogInterface dialog, + int which) { + pass = true; + synchronized (threadContext) { + threadContext.notify(); + } + } + }); + alert.setNegativeButton("No", + new DialogInterface.OnClickListener() { + @Override + public void onClick( + DialogInterface dialog, + int which) { + pass = false; + synchronized (threadContext) { + threadContext.notify(); + } + } + }); + alert.show(); + } + }); + + try { + synchronized (this) { + this.wait(); + } + } catch (InterruptedException e) { + mLogAdapter.logMessage("InterruptedException", true); + } + } + } + + // restore the default marshaller + mProxyService.syncProxySetJsonRPCMarshaller(defaultMarshaller); + } else { + Log.e(TAG, "Current test " + currentTest + + " or its requests " + currentTest.getRequests() + " is null!"); + } + + synchronized (_instance) { + _instance.notify(); + } + + Thread.currentThread().interrupt(); + } + }); + newThread.start(); + + try { + synchronized (this) { this.wait();} + } catch (InterruptedException e) { + mLogAdapter.logMessage("InterruptedException", true); + } + + newThread.interrupt(); + newThread = null; + return pass; + } + + public static ModuleTest getModuleTestInstance() { + return _instance; + } + + public Runnable getThreadContext() { + return threadContext; + } + + /** + * Logs debug information during the XML parsing process. Can be turned + * on/off with the DISPLAY_PARSER_DEBUG_INFO constant. + * + * @param s + * string to log + */ + private void logParserDebugInfo(String s) { + if (!DISPLAY_PARSER_DEBUG_INFO) { + return; + } + + Log.d(TAG, s); + } + + private void acquireWakeLock() { + if (wakeLock != null) { + wakeLock.release(); + wakeLock = null; + } + + try { + PowerManager pm = (PowerManager) mActivityInstance + .getSystemService(Context.POWER_SERVICE); + wakeLock = pm.newWakeLock(PowerManager.SCREEN_DIM_WAKE_LOCK + | PowerManager.ACQUIRE_CAUSES_WAKEUP + | PowerManager.ON_AFTER_RELEASE, TAG); + wakeLock.setReferenceCounted(false); + wakeLock.acquire(); + } catch (NullPointerException e) { + Log.w(TAG, "Can't acquire wakelock", e); + wakeLock = null; + } + } + + private void releaseWakeLock() { + if (wakeLock != null) { + wakeLock.release(); + wakeLock = null; + } else { + Log.d(TAG, "Can't release wakeLock, it's null"); + } + } +} + +/* + public void setParameters(String functionName, Object value) { + if (value != null) { + parameters.put(functionName, value); + } else { + parameters.remove(functionName); + } + } + + public Object getParameters(String functionName) { + return parameters.get(functionName); + } +*/ diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/Base64BinaryDataReader.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/Base64BinaryDataReader.java new file mode 100644 index 000000000..c70331ef4 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/Base64BinaryDataReader.java @@ -0,0 +1,53 @@ +package com.ford.syncV4.android.module.reader; + +import android.util.Log; + +import com.ford.syncV4.util.Base64; + +import java.io.IOException; + +/** + * Decodes the binary data from a Base64-encoded input string. The string must + * start with the "base64:" prefix. + * + * @author enikolsky + * + */ +public class Base64BinaryDataReader implements BinaryDataReader { + private static final String TAG = Base64BinaryDataReader.class.getSimpleName(); + private static final String BASE64_PREFIX = "base64:"; + + /* + * (non-Javadoc) + * + * @see + * com.ford.syncV4.android.module.BinaryDataReader#supportsReading(java. + * lang.String) + */ + @Override + public boolean supportsReading(String input) { + return input.startsWith(BASE64_PREFIX); + } + + /* + * (non-Javadoc) + * + * @see + * com.ford.syncV4.android.module.BinaryDataReader#read(java.lang.String) + */ + @Override + public byte[] read(String input) { + if (!supportsReading(input)) { + return null; + } + + String str = input.substring(BASE64_PREFIX.length()); + try { + return Base64.decode(str); + } catch (IOException e) { + Log.e(TAG, "Can't decode base64 string", e); + return null; + } + } + +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/BinaryDataReader.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/BinaryDataReader.java new file mode 100644 index 000000000..9ffda194a --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/BinaryDataReader.java @@ -0,0 +1,30 @@ +package com.ford.syncV4.android.module.reader; + +/** + * Interface for different readers of binary data. Used in XML test files. The + * whole data is read and returned in one pass. Thus, the readers should not + * store an internal state. + * + * @author enikolsky + * + */ +public interface BinaryDataReader { + /** + * Checks if this class supports the data format of the input string. + * + * @param input + * data source + * @return true if the class supports reading + */ + public boolean supportsReading(String input); + + /** + * Interprets the input string and returns an array of bytes representing + * the data. + * + * @param input + * data source + * @return interpreted data or null if failed to read + */ + public byte[] read(String input); +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/BinaryDataReaderFactory.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/BinaryDataReaderFactory.java new file mode 100644 index 000000000..ca2fa933b --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/BinaryDataReaderFactory.java @@ -0,0 +1,46 @@ +package com.ford.syncV4.android.module.reader; + +import java.util.ArrayList; +import java.util.List; + +/** + * Factory class that looks up and returns a class implementing the + * {@link BinaryDataReader} interface to parse the input string. + * + * Use the {@link #getReaderForString(String)} method to get a suitable reader. + * + * @author enikolsky + * @see BinaryDataReader + * + */ +public class BinaryDataReaderFactory { + private List<BinaryDataReader> readers = new ArrayList<BinaryDataReader>(3); + + /** + * Default constructor. Initializes the class. + */ + public BinaryDataReaderFactory() { + readers.add(new Base64BinaryDataReader()); + readers.add(new FileBinaryDataReader()); + // should always be the last one + readers.add(new PlainStringBinaryDataReader()); + } + + /** + * Finds and returns a reader suitable for reading data specified by the + * input string. + * + * @param input + * data source + * @return a class that can read the data or null if not found + */ + public BinaryDataReader getReaderForString(String input) { + for (BinaryDataReader reader : readers) { + if (reader.supportsReading(input)) { + return reader; + } + } + + return null; + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/FileBinaryDataReader.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/FileBinaryDataReader.java new file mode 100644 index 000000000..bb1345218 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/FileBinaryDataReader.java @@ -0,0 +1,78 @@ +package com.ford.syncV4.android.module.reader; + +import android.annotation.SuppressLint; +import android.util.Log; + +import java.io.BufferedInputStream; +import java.io.ByteArrayOutputStream; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; + +/** + * Reads the binary data from the file which name is specified by the input + * string. The path to the file must start with a reference to the external + * storage (e.g. "/sdcard/"). + * + * @author enikolsky + * + */ +public class FileBinaryDataReader implements BinaryDataReader { + private static final String TAG = FileBinaryDataReader.class + .getSimpleName(); + + /* + * (non-Javadoc) + * + * @see + * com.ford.syncV4.android.module.BinaryDataReader#supportsReading(java. + * lang.String) + */ + @SuppressLint("SdCardPath") + @Override + public boolean supportsReading(String input) { + return input.startsWith("/sdcard/"); + } + + /* + * (non-Javadoc) + * + * @see + * com.ford.syncV4.android.module.BinaryDataReader#read(java.lang.String) + */ + @Override + public byte[] read(String input) { + // fail fast if input is not supported + if (!supportsReading(input)) { + return null; + } + + InputStream is = null; + try { + is = new BufferedInputStream(new FileInputStream(input)); + ByteArrayOutputStream os = new ByteArrayOutputStream(is.available()); + final int buffersize = 4096; + final byte[] buffer = new byte[buffersize]; + int available = 0; + while ((available = is.read(buffer)) >= 0) { + os.write(buffer, 0, available); + } + return os.toByteArray(); + } catch (IOException e) { + Log.w(TAG, "Can't read file " + input, e); + return null; + } catch (OutOfMemoryError e) { + Log.e(TAG, "File " + input + " is too big", e); + return null; + } finally { + if (is != null) { + try { + is.close(); + } catch (IOException e) { + Log.e("SyncProxyTester", e.toString()); + } + } + } + } + +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/PlainStringBinaryDataReader.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/PlainStringBinaryDataReader.java new file mode 100644 index 000000000..8a64e0f45 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/module/reader/PlainStringBinaryDataReader.java @@ -0,0 +1,45 @@ +package com.ford.syncV4.android.module.reader; + +import android.util.Log; + +import com.ford.syncV4.util.Base64; + +import java.io.IOException; + +/** + * Converts a plain input string to binary data. + * + * @author enikolsky + */ +public class PlainStringBinaryDataReader implements BinaryDataReader { + private static final String TAG = + PlainStringBinaryDataReader.class.getSimpleName(); + + /* + * (non-Javadoc) + * + * @see + * com.ford.syncV4.android.module.BinaryDataReader#supportsReading(java. + * lang.String) + */ + @Override + public boolean supportsReading(String input) { + return true; + } + + /* + * (non-Javadoc) + * + * @see + * com.ford.syncV4.android.module.BinaryDataReader#read(java.lang.String) + */ + @Override + public byte[] read(String input) { + if (!supportsReading(input)) { + return null; + } + + return input.getBytes(); + } + +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/policies/PoliciesTest.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/policies/PoliciesTest.java new file mode 100644 index 000000000..ba126f9d2 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/policies/PoliciesTest.java @@ -0,0 +1,186 @@ +package com.ford.syncV4.android.policies; + +import java.io.File; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.io.UnsupportedEncodingException; +import java.net.MalformedURLException; +import java.net.ProtocolException; +import java.util.Scanner; +import java.util.Vector; + +import com.ford.syncV4.android.adapters.LogAdapter; +import com.ford.syncV4.android.service.ProxyService; +import com.ford.syncV4.proxy.RPCRequestFactory; +import com.ford.syncV4.proxy.rpc.EncodedSyncPData; +import com.ford.syncV4.util.DebugTool; +import com.ford.syncV4.exception.SyncException; + +import org.apache.http.HttpResponse; +import org.apache.http.client.HttpClient; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.entity.ByteArrayEntity; +import org.apache.http.impl.client.DefaultHttpClient; +import org.apache.http.params.BasicHttpParams; +import org.apache.http.params.HttpConnectionParams; +import org.apache.http.params.HttpParams; +import org.apache.http.util.EntityUtils; +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +import android.util.Log; + +public class PoliciesTest { + + private static final String TAG = "PoliciesTest"; + private static LogAdapter sMsgAdapter; + private static ProxyService sProxyService; + + public static void runPoliciesTest(ProxyService syncProxy, LogAdapter logAdapter) { + if (logAdapter == null) { + throw new NullPointerException(PoliciesTest.class.getSimpleName() + " LogAdapter can " + + "not be null"); + } + + sProxyService = syncProxy; + sMsgAdapter = logAdapter; + + String url = ""; + String jsonData = ""; + String encodedSyncPDataReceived; + try { + Scanner scanner = new Scanner(new FileReader("/sdcard/policiesRequest.txt")); + url = scanner.nextLine(); + Log.e("TestApp", url); + while (scanner.hasNextLine()) { + jsonData += scanner.nextLine().replaceAll(" ", ""); + //jsonData += scanner.nextLine(); + } + Log.e("TestApp", jsonData); + scanner.close(); + } catch (Exception e) { + sMsgAdapter.logMessage("Error reading policiesRequest.txt", Log.ERROR, e, true); + } + + encodedSyncPDataReceived = sendEncodedSyncPDataToUrl(url, jsonData, 10); + /* + encodedSyncPDataReceived = sProxyService.sendEncodedSyncPDataToUrl( + "http://applinkdev1.cloudapp.net/api/Ford", + "{\"data\":[\"RW5jb2R1U31uY1A=\"]}"); + */ + + if (encodedSyncPDataReceived != null) { + sMsgAdapter.logMessage(encodedSyncPDataReceived, Log.DEBUG, true); + try { + File out = new File("/sdcard/policiesResponse.txt"); + FileWriter writer = new FileWriter(out); + writer.flush(); + writer.write(encodedSyncPDataReceived); + writer.close(); + } catch (Exception e) { + sMsgAdapter.logMessage("Error writing to policiesResponse.txt", Log.ERROR, e, true); + } + } else sMsgAdapter.logMessage("Error communicating with server", Log.ERROR, true); + } + + public static String sendEncodedSyncPDataToUrl(String urlString, String encodedSyncPData, Integer timeout) { + try { + final int CONNECTION_TIMEOUT = timeout * 1000; // in ms + + Vector<String> encodedSyncPDataReceived = new Vector<String>(); + + // Form the JSON message to send to the cloud + byte[] bytesToSend = encodedSyncPData.getBytes("UTF-8"); + + // Send the Bytes to the Cloud and get the Response + HttpParams httpParams = new BasicHttpParams(); + HttpConnectionParams.setConnectionTimeout(httpParams, CONNECTION_TIMEOUT); + HttpConnectionParams.setSoTimeout(httpParams, CONNECTION_TIMEOUT); + HttpClient client = new DefaultHttpClient(httpParams); + HttpPost request = new HttpPost(urlString); + request.setHeader("Content-type", "application/json"); + request.setEntity(new ByteArrayEntity(bytesToSend)); + HttpResponse response = client.execute(request); + + /* + //todo: write to ui + + //public boolean post (Runnable action) + mImageView.post(new Runnable() { + public void run() { + mImageView.setImageBitmap(bitmap); + } + }); + */ + + // If response is null, then return + if (response == null) { + Log.e(TAG, "Response from server returned null: "); + return null; + } + + String returnVal; + if (response.getStatusLine().getStatusCode() == 200) { + Log.e(TAG, "Status 200"); + // Convert the response to JSON + returnVal = EntityUtils.toString(response.getEntity(), "UTF-8"); + JSONObject jsonResponse = new JSONObject(returnVal); + + // Create and send the encodedSyncPData message back to SYNC + if (jsonResponse.get("data") instanceof JSONArray) { + JSONArray jsonArray = jsonResponse.getJSONArray("data"); + for (int i = 0; i < jsonArray.length(); i++) { + if (jsonArray.get(i) instanceof String) { + encodedSyncPDataReceived.add(jsonArray.getString(i)); + } + } + } else if (jsonResponse.get("data") instanceof String) { + encodedSyncPDataReceived.add(jsonResponse.getString("data")); + } else { + Log.e(TAG, "sendEncodedSyncPDataToUrl: Data in JSON Object neither an array nor a string."); + // Exit method + return null; + } + + } else if (response.getStatusLine().getStatusCode() == 500) { + returnVal = "Error 500"; + } else { + returnVal = "Unknown Error"; + } + + //todo: write to ui + + // Send new encodedSyncPDataRequest to SYNC + EncodedSyncPData encodedSyncPDataRequest = RPCRequestFactory.buildEncodedSyncPData(encodedSyncPDataReceived, 65535); + + //if(getIsConnected() { + + /* + * // Send new encodedSyncPDataRequest to SYNC + if (getIsConnected()) { + sendRPCRequestPrivate(encodedSyncPDataRequest); + } + */ + if (sProxyService != null) { + //sendRPCRequestPrivate(encodedSyncPDataRequest); + sProxyService.syncProxySendRPCRequest(encodedSyncPDataRequest); + } + return returnVal; + } catch (JSONException e) { + DebugTool.logError("sendEncodedSyncPDataToUrl: JSONException: ", e); + } catch (UnsupportedEncodingException e) { + DebugTool.logError("sendEncodedSyncPDataToUrl: Could not encode string.", e); + } catch (ProtocolException e) { + DebugTool.logError("sendEncodedSyncPDataToUrl: Could not set request method to post.", e); + } catch (MalformedURLException e) { + DebugTool.logError("sendEncodedSyncPDataToUrl: URL Exception when sending EncodedSyncPData to an external server.", e); + } catch (IOException e) { + DebugTool.logError("sendEncodedSyncPDataToUrl: IOException: ", e); + } catch (Exception e) { + DebugTool.logError("sendEncodedSyncPDataToUrl: Unexpected Exception: ", e); + } + return null; + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/policies/PoliciesTesterActivity.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/policies/PoliciesTesterActivity.java new file mode 100644 index 000000000..abe6cac7a --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/policies/PoliciesTesterActivity.java @@ -0,0 +1,885 @@ +package com.ford.syncV4.android.policies; + +import android.annotation.SuppressLint; +import android.app.Activity; +import android.bluetooth.BluetoothAdapter; +import android.content.Context; +import android.content.Intent; +import android.os.Bundle; +import android.os.Environment; +import android.util.Base64; +import android.util.Log; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.inputmethod.InputMethodManager; +import android.widget.AdapterView; +import android.widget.AdapterView.OnItemClickListener; +import android.widget.ArrayAdapter; +import android.widget.EditText; +import android.widget.ListView; +import android.widget.ScrollView; +import android.widget.Spinner; +import android.widget.TextView; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.adapters.LogAdapter; +import com.ford.syncV4.android.service.EncodedSyncPDataHeader; +import com.ford.syncV4.android.service.IProxyServiceConnection; +import com.ford.syncV4.android.service.ProxyService; +import com.ford.syncV4.android.service.ProxyServiceBinder; +import com.ford.syncV4.android.service.ProxyServiceConnectionProxy; +import com.ford.syncV4.exception.SyncException; +import com.ford.syncV4.proxy.SyncProxyALM; +import com.ford.syncV4.proxy.rpc.EncodedSyncPData; + +import org.apache.http.HttpResponse; +import org.apache.http.client.ClientProtocolException; +import org.apache.http.client.HttpClient; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.entity.ByteArrayEntity; +import org.apache.http.impl.client.DefaultHttpClient; +import org.apache.http.params.BasicHttpParams; +import org.apache.http.params.HttpConnectionParams; +import org.apache.http.params.HttpParams; +import org.apache.http.util.EntityUtils; +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.io.UnsupportedEncodingException; +import java.net.MalformedURLException; +import java.util.ArrayList; +import java.util.List; +import java.util.Scanner; +import java.util.Vector; + +@SuppressLint("NewApi") +public class PoliciesTesterActivity extends Activity implements OnClickListener, IProxyServiceConnection { + + private static final int SOCKET_TIMEOUT = 3; + /** + * Called when the activity is first created. + */ + + protected static UIMessageAdapter _UImsgAdapter1 = null; + private static final String LOG_TAG = "PoliciesTestApp"; + boolean isSYNCPaired = false; + boolean fullUIDebug = false; + boolean startAdWithAlert = false; + boolean useSYNCTTS = false; + boolean endWithSurvey = false; + private static LogAdapter _msgAdapter; + private static SyncProxyALM _syncProxy; + private int requestCounter = 1; + + protected static byte[] _ESN; + static EncodedSyncPDataHeader _encodedSyncPDataHeader; + + private static BluetoothAdapter _btAdapter = null; + protected static PoliciesTesterActivity _instance = null; + //protected PostThreadActivity _postThreadActivity; + + private TextView _console = null; + private ScrollView _scroller = null; + private ListView _listview = null; + private Spinner spinner2; + private Spinner spinner3; + private Spinner spinner4; + public int timeout; + String url = "http://applinkdev1.cloudapp.net/api/policies?appid=1234"; + //String url = "http://applinkdevap.cloudapp.net/api/policies?appid=1234"; + String data = ""; + + // TODO : Implement base Activity which binds to Service and extend form it this one + private final ProxyServiceConnectionProxy mProxyServiceConnectionProxy = + new ProxyServiceConnectionProxy(this); + private ProxyService mBoundProxyService; + + /** + * ******************** + * * UI Menu Functions ** + * ******************** + */ + public static void setESN(byte[] ESN) { + _ESN = ESN; + } + + public static void setHeader(EncodedSyncPDataHeader encodedSyncPDataHeader) { + Log.i("syncp", "_encodedSyncPDataHeader = encodedSyncPDataHeader"); + _encodedSyncPDataHeader = encodedSyncPDataHeader; + } + + public boolean onCreateOptionsMenu(Menu menu) { + boolean result = super.onCreateOptionsMenu(menu); + + if (result) { + menu.add(0, 1, 0, "Policies"); + menu.add(0, 2, 0, "Exit"); + //menu.add(0, 3, 0, "Start"); + //menu.add(0, 6, 0, "Exit"); + return true; + } else return false; + } + + public boolean onOptionsItemSelected(MenuItem item) { + // Refresh the instance + //_applinkService = AppLinkService.getInstance(); + + switch (item.getItemId()) { + case 1: + policies(timeout); + //testerMain.restart(); + break; + case 2: + super.finish(); + break; + /*case 3: + _testerMain.policies(); + break; + case 6: + _applinkService.stopSelf(); + super.finish(); + break;*/ + default: + return true; + } + return false; + } + + @Override + protected void onStart() { + super.onStart(); + + if (mBoundProxyService != null) { + // TODO : Consider the case of NULL + } else { + bindProxyService(this, mProxyServiceConnectionProxy); + } + } + + /** + * ******************** + * * OnCreate/onDestroy ** + * ********************* + */ + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + _instance = this; + + setContentView(R.layout.policiesmain); + + setRequestedOrientation(1); + + _console = (TextView) findViewById(R.id.console); + _scroller = (ScrollView) findViewById(R.id.scrollConsole); + _listview = (ListView) findViewById(R.id.messageList); + _UImsgAdapter1 = new UIMessageAdapter(this, R.layout.policiesrow); + _listview.setClickable(true); + _listview.setAdapter(_UImsgAdapter1); + _listview.setTranscriptMode(ListView.TRANSCRIPT_MODE_ALWAYS_SCROLL); + findViewById(R.id.btnSend).setOnClickListener(this); + + _listview.setOnItemClickListener(new OnItemClickListener() { + public void onItemClick(AdapterView<?> parent, View view, int position, long id) { + Object listObj = parent.getItemAtPosition(position); + } + }); + addItemsOnSpinner2(); + addItemsOnSpinner3(); + addItemsOnSpinner4(); + requestGPStoGetESN(); + // Create and Start the AppLink Service + //startAppLinkService(); + + //policies(10); + } + + @Override + public void onDestroy() { + logMessage(PoliciesTesterActivity.class.getSimpleName() + " On Destroy"); + + _instance = null; + //endAppLinkInstance("onDestroy"); + unbindProxyService(PoliciesTesterActivity.this, mProxyServiceConnectionProxy); + + super.onDestroy(); + } + + @Override + public void onProxyServiceConnected(ProxyServiceBinder service) { + Log.i(LOG_TAG, PoliciesTesterActivity.class.getSimpleName() + " ProxyService connected " + + service); + mBoundProxyService = service.getService(); + } + + @Override + public void onProxyServiceDisconnected() { + Log.i(LOG_TAG, PoliciesTesterActivity.class.getSimpleName() + " ProxyService disconnected"); + mBoundProxyService = null; + } + + private void bindProxyService(Context context, ProxyServiceConnectionProxy connectionProxy) { + Log.i(LOG_TAG, PoliciesTesterActivity.class.getSimpleName() + " Bind ProxyService," + + "connection proxy: " + connectionProxy); + context.bindService(new Intent(context, ProxyService.class), connectionProxy, BIND_AUTO_CREATE); + } + + private void unbindProxyService(Context context, ProxyServiceConnectionProxy connectionProxy) { + if (!connectionProxy.isConnected()) { + Log.v(LOG_TAG, PoliciesTesterActivity.class.getSimpleName() + " ServiceConnection is not" + + " connected, ignoring unbindService: " + connectionProxy); + return; + } + try { + Log.i(LOG_TAG, PoliciesTesterActivity.class.getSimpleName() + " Unbind Service(), " + + "connection proxy: " + connectionProxy); + context.unbindService(connectionProxy); + } catch (IllegalArgumentException iae) { + // sometimes this exception is still thrown, in spite of isConnected() check above + // simply ignore this exception + Log.w(LOG_TAG, PoliciesTesterActivity.class.getSimpleName() + " Unbind " + + "IllegalArgumentException: " + iae); + } catch (Exception e) { + Log.e(LOG_TAG, PoliciesTesterActivity.class.getSimpleName() + " Error unbinding from " + + "connection: " + connectionProxy, e); + } + } + + public static PoliciesTesterActivity getInstance() { + return _instance; + } + + public Context getMainContext() { + return this; + } + + public void requestGPStoGetESN() { + //EncodedSyncPData + EncodedSyncPData msg = new EncodedSyncPData(); + Vector<String> syncPData = new Vector<String>(); + syncPData.add("AAM4AAkAAAAAAAAAAAA="); + msg.setData(syncPData); + msg.setCorrelationID(6000); + + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } + + //add items into spinner dynamically + public void addItemsOnSpinner2() { + spinner2 = (Spinner) findViewById(R.id.spinner2); + List<String> list = new ArrayList<String>(); + //list.add("start packet EU"); + //list.add("start packet APA"); + list.add("file"); + list.add("wake up ARMR packet"); + list.add("packet 1"); + list.add("packet 2"); + list.add("packet 3"); + list.add("packet 4"); + list.add("packet 5"); + list.add("packet 6"); + list.add("packet 7"); + list.add("packet 8"); + list.add("packet 9"); + list.add("packet 10"); + ArrayAdapter<String> dataAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item, list); + dataAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + spinner2.setAdapter(dataAdapter); + } + + public void addItemsOnSpinner3() { + spinner3 = (Spinner) findViewById(R.id.spinner3); + List<String> list = new ArrayList<String>(); + //list.add("start packet EU"); + //list.add("start packet APA"); + list.add("send to cloud"); + list.add("send to SYNC"); + ArrayAdapter<String> dataAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item, list); + dataAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + spinner3.setAdapter(dataAdapter); + } + + public void addItemsOnSpinner4() { + spinner4 = (Spinner) findViewById(R.id.spinner4); + List<String> list = new ArrayList<String>(); + list.add("NA Endpoint URL"); + list.add("APA Endpoint URL"); + ArrayAdapter<String> dataAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item, list); + dataAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + spinner4.setAdapter(dataAdapter); + } + + public void onClick(View v) { + // TODO Auto-generated method stub + if (v == findViewById(R.id.btnSend)) { + //logMessage("starting"); + //runOnUiThread(new Runnable() { + // public void run() { _UImsgAdapter1.add("starting"); } + //}); + + //get timeout value + EditText editText = (EditText) findViewById(R.id.timeoutInput); + String editTextStr = editText.getText().toString(); + timeout = Integer.parseInt(editTextStr); + Log.i(LOG_TAG, "request #" + requestCounter + " timeout value: " + editTextStr); + + //clear keyboard + InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); + imm.hideSoftInputFromWindow(editText.getWindowToken(), 0); + + Log.i("dropdown", String.valueOf(spinner4.getSelectedItem())); + if (spinner4.getSelectedItem() == "NA Endpoint URL") { + url = "http://applinkdev1.cloudapp.net/api/policies?appid=1234"; + } + if (spinner4.getSelectedItem() == "APA Endpoint URL") { + url = "http://applinkdevap.cloudapp.net/api/policies?appid=1234"; + } + + Log.i("dropdown", String.valueOf(spinner2.getSelectedItem())); + // final String data = "{\"data\":[\"HwcaAABt2lhQMjIwMEtHAAAABQAAAAUAHRHcxKMmVbBKTj6F3qEH4Wq0/zA=\"]}"; + /* + if (spinner2.getSelectedItem() == "start packet EU"){ + //ID=5 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 1"){ + //ID=6 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 2"){ + //ID=7 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 3"){ + //ID=8 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 4"){ + //ID=9 + data = "{\"data\":[\"HwcZAABt2kZLOVAwMDk0AAAACQAAAAEAolsAtRsFjXdBb1UK7dQH/GOZ/pxfUXyyiHaSHu0McMPS27dxGjDyQJePR/1C2Q7JH1pquWxc6CuMLr09enhWO+GVeWFxruZ0dnUyJKLNBdh6e1MWMZ77fPnKb5P/FtGPo7pLLvDZ2gYWe/wwHoOJNxB4Xe6jV6t/h2rmOi7yUCLpOQFm0n5G4SnXn+0r3AEuPMQT9n6xVk7XoLpuWIx7ilDQL+jRqGFJmWl8fZKd7ocvK5KRBoQUM9rYhqBS+IwQnrOWdPaS9KCP5TaW5pB8W1sOHobK4wcIQEYr6XvFoxRA4da3jbKEEgINzBTthcYv+fAQ1ZZs85vQXxFsPLo6pwYrAL86bC0wh59+wEPEYlsnlEKqUhbGTwIfFIWw2XGU4vkLACMOJBrxkiL7uiKoGscADqPF88qywFtY+cOqd/JhiRr52TSwLA9nEMv7kn0TNL2OsyzHBakUHYbeJfOsCcOyHROK9/9JV15HYFzd5YvvD0IqGa+FAq3tUfpbPB2qFJDCcrlogRmfv9YZtyJyC82vHIPfBZWX7D2RLahAPI47YiZP59T5WFBWCK6KEWFX5RJETQMuhpfvcId3P0NF1GUIhkVwWuJ9kNj8VkjVZTAc/EQ8ehQABJtHgRlMvogB2oKB2TO4LoiIyyARq76I3f7O7pudyGUSINj75FK4tpvmxj0+hNBI+APZNhoLCBE5UgCJC76FbIvS8IkzSUgqeYZrXlNGIu2V1HyRKrJDFsgjp2Rr8vtaxz+qHp9YACmJPrpJJMscdibsR72zYyPNLcUxFG9+eNtVjeEO7OAW+tPV2fXot6inB1weZG+Zb4pMaC7fEYL/FNJ/wZfLF2EN1mlFFW7ZD8qanO8GmPaGiXxhaUpFD1tW+O+aAPhpCOTfnhL6QibRmkSFew7sxUnd20gEQHGea62BWara8OhkBURJ9QC66B7rnYi6+q5NxpjLaoMZM3A6FSmEklp9mig02a+w04vVn2gbYK7U/zojk8zvtvChdaxLjhXBSIGsRuFwXNaSqcZT+zEOKTWIHL9k4Ab13e7GKE1JCtiqzAQMJPb2d0Nqm4uVnO3aeOgbWK6zxAMrrNzEVhcBB3m/eJ7bxeiSFYpuGowD2Sgne5S2OLDa4iUXUcnt49o/V10SBPVda5M9avJ0fGwEK2dffVIA7PWN9SXz4L/3D0BdQChdQpeS/Pk/9lWmmz8yOUjXN6pJd9T8168HujXL8PUeFZ6phARzc/Xd89qYFIjbf9YV1TAnLOSeEsKAfPV8kOVvKXsDTgGJtLwk0j7mP6xj0hQvpMm7ri6CFa2vXcV07x4oDsq8kxdd6/0zxQfwcHOJTpXWIBqzrL7I2fmh2QuWolNhPcIap+rgkNcFh7QhrsFmjS/zKzHBinQQMKgndU0GiCgWdx8TNWk07twKKVYdnv+dMG8iamlonObVLBCEAtuHzyvPP2dV9yW0+9hO5lA+vzn/NnEJ7cHl1ap6Ec6EQeLKmv1Z3H8U2g28wSt6BOnjH82TlIBrsIOxb9bX9bv3nH4dM7/gU5SoKLrW4CtAYkAI1fOaWAK16ceDzlTSBSIeTblDH6w9cOJ/wwkErmofVvCUApZkShvGeeNOYVta/ipl7MIVrVOTVpTeIrWKDE1OnmzakeyXl/XLIa7mXGdiWZXbi25Dl4PGeJlIt9Tvuf904K/QeuMc7bNTpjuwyr4+aD+4gCKIKLgtDdsfcPVI4ZgUEsdCBcivqGEYluek2Vh3OUB3wdp8pieRtYEQzM9NMF6oUHWIKZOQ8wd9jY4NMDOZ0GtuyWYU1HDLVqm+rMPhH94bIKtZR5ytipDXr+uEbt+KTdKsdsqrnsrrMkO9+wFOkHTOoUDsBcWlDc+r6upm72jFi5WI0czm6+ehm7aPbwAN48Bjalflw5HgYjS/9EOhMfdi/M53OZjNeueoZmWKWaLgVajh6J1n8+LXGCALI2U3RRDLsU/729/lGIFjNcYNctRnUF4F/tQGywkSwX8iL01OXTHsrnDTpP9kwJiD42YDP9UhzIC1w/zV88k+y0DA2q/1fcvF+ynBFwtw7T9Iy2dEaOViJeF9iyXzkTLGlGFn+NnSwXxzsjR07OHPQ0JUjjJcTChYhu5yLxLQcnoaGTyPbVciREOHnwaTiuXCG6AKFtKS5OH5CjLI9j1o8waTKeyJsnLBj7STQ3fK3F6/HFZ8cx0LdRjT3WwThLZ47KCYLbwNRlSM4HlVeaNfxBKguRcKI4yZPEnBHmEe3hNMTRPbUVuKE3x53LQbk51IfdTefSHFVc5cSX2Awr3tAuLj9/AOGRLAsxllHV5R0ZwmyBupgFGevYc1xlyQ9JsQzHQXoM9K8+Go292rA5Jmp7UmXT2AWOXEZZvaEns1T8GEQ3s8ljQy4Z9xble8u2reydYzB/g0ltvDr9ZvH4MjPM94+n0w92R6E89Jo7aSGsYCvnDW0Q+nJE80irNg/Rim0mTB9E739BZBM6Hfucmad1M1hsekWTEzLHhLrScp6g8OuZTCIqjSSvz7BgvMv6+pbdATjsk/otCGOLcpaAOJoQfSY9M1YjgbasVzvdwIyr1q5qzeKkP3On6TPbXGxCrJtNbqeXFpbgI6IAFAM/K58ja2rTRlMb1F2ezZcLbeAf5JddzqVp8OT8yUELQxUGeC91vm0EPWtgypwex1M90dqB98DW1E4aAJTpl0JKCq1pbb0DEbJTWaW6B9W2TyqPlgVISvXftL4Mktg+j+bYgFt0sSuOMvQc6svA7dfw8DUs5eDtYGiTgiYixfUs2mJQpd2XGG+l3cm/n/lHyFE49TOCg2MmoRlZy3SppKtFdadJ3k3gtNYzHJJcDNZoQJ61qzLt0P6fgkIUnAr5AznDzX+yWNDe8LI/3xJUhdyhn5uCug090D5skunyguOIoxDAXnRnoZspSqtuDN+oIrAyY4tb7cVEasQVfl4oGfYwo9cD8sOU109Y7v+bKQRNJyfEJWgYGDKTUdMIg/8so60t+fhhx9VD4IvZCQKDm9SVn2KSDMcB7TAkOlON4+TUFClp2dFpRG3d8yUv74IpHFbz4j/b7+An0hm4QUGZv52jEpxRgJ5zUQXRdeARI7ZwIW5MwyLcrvOVlZuW4xsmcbd01Sdlpnlud9ipvvjYSetETTY6RDD3KjvOfZlb+rjwN6DrK7Cy/gqh9aiMYAmczJDTSlgmTJBVEyYy9pceBCY+SVtTaYaTiUdj/JPPUJmDLgq6EraYvMMO6AJylra8JqzxZFnpPqG1THUiUMYgaIMA/K3qQOsUpBAtSK5PV7b3MUYL0b+lqdkNh4VOae8lGbttbZZ82GByaeCOLU6VoqlSYZxpiUSiFK0udrNLQbNTJIu3UDxPVUZ642uF6yQLmxyax7yvB4hGpOGuW/VuvvUrG26cG2aNggaYcmJKC0Y4Ph+SqS7TGoEMkgc8gd2EG+AhfVGOnNYUjOQrZeuQ4b8CRPhMV897VomXhiDjKQ05XMzLZr4PudWMXYRYUkmySQfS8bEWn0GoEvnw4SoAu4vh7VeAop2uz4WdcMbMsZJ9JWi8ekZ/nZdwT4bLT1LLSkVe40N5I0ZlPHtw8+11Gx1vi0hOlxk0AxzTg/yFLB0uhEZ8rflCPiZ/jTbqvSRD/A0afk/kMTz6+xbqZv/KfEtR/k+NokIjCjCBdHsggw+NwryDoj6AoFz2KmViT+WgHOz5YQ3VHp1m8DblZ6Q1DDOmq8VyHi/k2O39P7jwSEOyzfrCWJp2AOnNIQgg8rpdQ1pNoCm0JM7QEDX0eFHEAE+EQUawu9/mZXSAhB+8cWOlp9/O7OvpCdfu6NiNTYlXit6++priqCl5r0R771QlZQxs4hF2BGP3uuv8bykeSTK+JKoDAYQrIOpUvuGjKDouIznxqZ9iiKb/c7Vwzojv5pkOGzbooY/csHU1SSqkXoeufuJwO9hPb55Nle8he0CYbiXY3B+zCjqhv3jeXXy5pGHd87lnissAxA98Nb0gH5/xLnsS96/6afwfCAGPx+B8xZJxja5isMThXhHuqYCV/eZ5Blu8CYMAb+oODgznX017jzU5vhb5//lRvqsY14PI0OTVIt11RPRAt0HjBOAGW0y8so2q73861YO6RQKjNF1ctkzt8mozAQhvxbZm9piO13WZksgLgiGVrW4QRFInHf7m9WRZ/gdAzWkzpfJsYuxBJUSC3ZDGEWB+AiStG0d7EIutsBQaJV7/HlGBqS/6zm3pZduqo5riPW786w1ES3Pi0tARrgGCtp3AmwcvPCnwc12dGX0OhXmyTUsQbdrNkzEoDYyD2ot6n+PDGtgOT7NsbIuikOSQpuiivrX05q1F62j8CVKXasOUrOlejRawsyS7jxE/sDVS1t7+E6baJ/0IEWO1ho38Xb2GGehBBNT/OIo+YgCeSieyQuO7b/dihehdAa5BT/tDUmTGQZa1u7lYL6DfyPasSw9uU3RrU3hdib/8LTqhTMu7gIGJLP6avL4KKSyFGBHsxLZ8lHgyCc6hSgqdatR+6JfYQ62tPRIGvTiGSS7xuYPlZGkZJ9Ic1MZJQSe2gPtMO6zMacrq7IujFpkZdJcoI+wpF/Fvg5TBSd4eGI+IfQyGdbS8oUktOEJMamHej4Pa8oZ5D1rBQXZGfx1XvLn3aAJK0dsov0eE1sxjYKKQzBVxUR2HtHJs0gl6ZJ+mALhq46GCMFyOshIqfM519VLegc63wK43f+SN11oLfZB1vutj+33Yonywf3y6ri8txX7LRPxX8nP/tJU5wuzvX8xTXsuPZybrcYIOjBZipVu2dPMCDlz9LwgThh1R7eYVrfSeUyHcV7IC45pPq2REK9dTCXgSzr05EBCyeWHoUWY1Txk/wcg8xRFaHhfI+O7BrLMtoaoOK+gO24FYZRNxO7XmJFE4m2BGj8PqgJG99m1KQ8S/8lInlkfWlh92x5zJ036oeCd3lsTogYz8ZjyiBnnhg8B2a3s0KvVrQSrz5oaxtqZ5tTQ141vWD3sa73hR17BSitsfi5OUarx8dX2ezWXDMy2l35QOuC9ttbxuIH338FeCQZlPAHLj+4J7cX4tRSd2fKw4ODXAlxSipTwf+IVAuRiEl6sHz/FKSgBa40EUZxfgecMx8yjeU6jgUqPdXNzK5TawEm5D20+4yez1HPAE5U7QA3vJCp1vo/yOiACNKB0ANnKS1Ta+8+/urbvxbFbfLKV73A6+R23xYRzQuwdMLheZO+RsckdvbM9/RZiHPxP7S2movQtt/7/yKhJEtfOFRD9IIG6Kp1tehU3Vm0kKGQsoiT8KDGr9OIUb9WX7j7tinOzNuQCORhFbahPFvYK5tGlQHJMlSnbkg7d3FNTA6tqCJlrigEjB0ilKtpUP2K0hYNh1DlJPO3zp/mmOFsZQhCLo7mk9LCgulwiX4269xDLh5w6oMFKpSEMdfBclJujImjcNyGarvzYwmB2wtVlSIe3b7pNt5CkR7Jy8cuXuAWLLihueBquEFNIjVRDvr53bLgcc1t84YaCPS1A/JvykYcR06sLMiwCxWjxRxwMuUJtUo+C7NME7fPYi3NhTvTgRddIYpBDAXelrN095XNmqQ3gWxKVGNGuzvShNbVd+zP8GnjOOtqnyOMEIhPjRrPF3EyxI0vY4f/tM/p/fFxp0bMAxSZbwqTn0gG9QhWraf+Gndmmm8BsQikjxJ8o9j8mIHNuOVSY5CTgw8J28Uuu1B4CTLuXIN+u7xJXCna0FFnHQrxIPjiLqzbv1rF4gHu6V6RnZUG1x8o/LCCTvyVD4WU7sSJM8jvBVGig1bGGwR9Sx5bwuFqabplDdv+sRVKQJDCadZGDh3pp+PzbZrZZ2lngjHejwA5S2sva27RNPPceYsrbpXgFal+wlbsqetbcWuzB8oyr+vbdD46AWxa/MeHPZUuJUZX2lmIIfcNgJe+R2mq2AU4eNhQSJ8mc9/fGoGdHEaJXixIbpE3KF8F0Uxn8MTZoWUKWQHew8p/P3G+rzqRbdxNNYW+luL+KwciHE+ERUm9e6AOi0C39w5Yrm7QSFUOy8UfIA7Mb5qPiilDGq3f/pRWTvTTn7lWT9MCeFR79sZb+vq/lj/Wg4hu4EgzZUG+X7tCKJoa3KbQDKya2AiKNHlyHTYavcbqzj9OTlGGD+yFuRzTlT4lLJs+b7564jZ74XXq4KV6/EjlstwwIOqnRY7cOCZvCMSQLZb5Fu0W/o7INpG48YGMg/TpFV+gnN8ckZKO0uV0mfNftB0IgA1vCmKVLXKQ1kvlPuJ3p346K71gqHEMsNG+6Lp9syOmb0Nj0Y78m84qxQvSSKQ7bRxtjpTQzLAhemln1ZomIRcDoCgeeGYmGVBuhRkHsZv+e7AqjYLu9w5NFOOgZFjr4hN9sLfYhOmVxEK5yzwxT6T34193pONgM6V6+X7pFNHsW4cySsCsvqZzk3eX67ly/9NrgnlG3JlIcA9pDtgENJMaZ7fQTugpKRnOjhYAEOYwPzrDE5tLiEgqqVJ7iXIZH2gOnKVIzpPwj2IoHtzeoXAYSRR2BJsDgv86HQhvQxgMfsCLT51HHBQuz/SQ9Y0/kYSJaOgL0XqFWQHMYHc0zNL20buDrO04pXZg6OrOjRa49Y+Z2wFwocleonjCdqgXgpQ1QI58j4DdtS7/YJOd9A1G+L6/tihPttmfy61aJ1+RV6lRJvb4+A8F0f46k/l60ZpG7S4SvXJHg6ZZeemtfSRZwaSW+sP46w5S+uVwD7s20YnV/8zsrG926cXk7PNu/NkJYf+HNH0bkjQd0DY1thElfPVoNoyY/Kgd+6kHqYR0RkihIDFdQErnk6PBl7UInzcvlCWnMjPtuKXEFhXiqzrz11R0aLcRFJJILTcucxH1hVNmWZYxq4WFuZFA/ym8rlZOAoFrNgcVwLd+cdP+p0ze7KZft5Yci+VUMdQKOcCTHQQBSZuHcehqc3i5KbNfVhw67+sbOGs347dk0i/tIoiTPJPWUlrJUK2omGx6ntyYRvB8RuQYhDCV5LJQGq0CHm4S1kajve+4WuPQSAaStOZxCyWWVSWP4O+wA20YFSaWE3ub78lISFNT2pRi4TcelazvEqcBEJ4UQI4+EdZ3JARVVfuyFdSYhYNZVSSupf9FfoLwersXGMj0flzJ5bK5bBcN+HRQNIN3+ruXZ2xT6QGnqUw1BOiQVg+lgtfP6d++XVpXsJgTQKMzGwMAQegUzMLT+ZTjHB45eNmK52v/kptMMVnptnkxp5/H0M63G0JX6VkpRGu+X09W7sWuPNUuA6tP7Oujjsv+LCc4lfNurKEVR3NPpl5xn9jAgcp131m5VbpveYD9RHG7pCwyk/uHpqOSNULxJgFjLVizl4KCffWj66/e8e12738v1csr1RXAa3xsR1xRUpPf13X2d7nlAMWHLI8kyda89XXRlzhnphno/PmocMFP2umhgGFZL4bFkCRM6UPf99ZzGhH7bt95tvWzPa2joW1PpFNmLd6BVJlYGE2IqcvACawvZ77cQ0RiSZvy4eHahX+yoHeeVR2uGezFqyb8JwQz3A1OKOJa9WewtWRzMWqQmFO8rTrJA3U+FgPl57A543G2htIOWVIdis6L313Ry0DQkU4izzOto12wyw5SkWQdZENcr23RSC+Em71DMg/pKmzeQfdRlr1Bk9lhJcBr13cFfqnYURllsiF4pjkL/0dv9RTMbaR7kHJ4m7Lg7tfMaTxJ5IHdQLfMEnKITGh+WGX81UZvZTmfyiUhdtwfqu/kjAKKW6DfETNC7xC9hFHqtnVa+ZigEtrwGtbzcMFK5OjzHYs/vodrtPSFmeXWMq3FMRpsBmwenC1CCrpW1ANl+idF2wBsji7DNGlxj5kHn5xrtpPTPnhzEie0zISDbr6KkBntEUqshoJZYZauz6bmpAzksvc7RhqRQVcHPCMMohuVRusJrpek2bj6+IitBvL68WZBFMLJT6u9X8Cpnnveq/8nQVauQkWsRDs3mL8TnIiy1fw5C6dlNEZGaXUF3Q4efmjLzbYv2h/vG3hgeyv0DCqw2Sw4lOTj8EgXhhCzWcvAFN7vmsjsL+g5E8cwqDr6NNz9EqH/MkC4fmU06TvLEBLha/S282eWXida6yqrF8lDMUhIX4Nvie1qu9wCMrI2wQNQywh81K0akoZgRHUsF/7N3g7hcjYz5eAFmhIm6i1WxKJbtKhCMC7QCY+o8V7nRnC2jeUS5ATqRkU8mEk9/EK6ljxtgU2Ga8bh46Ky+gR8ERtG1keXwBt5Qyqsjb/36BtL+i64tJpqPFkqj0FCYoVoJ5Qd6z1J4mD39Qx+3NbHBDYGMQdHDAIkX8b9JR9GHv0dKXUD/jTet51HMPX4bYD6lQy+otnd0nIpH61VPz2j2xy8Qk1Xp9qdfdY9r+cbDQ3q2ZNC1BwfaBnZMNsdpt8ykEwzml6hTmMegSHY4R6xyOPu5zArL5Hs2v5S9ePv3WKF8dV6iVBUNI0iMXLtFpwJAJ0NNIojL27q3uyKKE86W30xCRu8i3QVhn6bKJXlw+orR8QJsp0LYbM3KntrQFCAWMwjXxe3AQ+k5V7u1S7y+lVQHhWNjIvV8NXo7+KCjzhh3fu0UESn4ZIbCqOZ6PIYQZRMDMmUk5O86NA13bT+3vTbxO/tv5Gat6XVghWgQe4HWeKsOTJ6ARJ1du0dep29qELX4jFobPqVxuWdJWHdGYZJOw9GAF/EUC9MYRBHmsEfj+SNNfIkbsczzzrdwXxFa4fzoajJ8Uu4nXfJqpHG7gtzBGKsNqxFC5GKPsVr6vW+/OwoWZqXDJijMCEpZNmqlaUU9XOd1FlDWiMgZKQuct4FeKbkE+tJwtu+WJgnhdlKQVkunNxFwi6nxFihaCkpgiCZvpEyOKTsZOZQqptlpVU1b9PHMstZ8yy8xLOk2OklOjRs3mZPIoI96FSKUeiJlQgkMtQ1xLGcekzG8+Hi8BcV4rOiK25H5MqjgsFXg5lrfjMExu9DkZcN002n1hSPt35Tr6s78d+VgecGIKH1bDJ3RDYhBxxas9+haJ8xivAAUSZ+dXywaTB1AbWIqDtQIfSnfuxQXMcRJiNNYmcYZVuQ4YSjgHrwRML4gNN9wLJLNlCPEbguGhIOcuTl3hVD3/aJleTj/gMuTUq9WwEOMobhMVic7GLCIKrZqwdhWu7P4jxEgV79PoWmoO8tovH14BXS5BUwx4HZXPliEdE5cnh2qrebX6d7OiIblKZFLGdIJAoSRIVbtxzzE1P7GxRKDwL7AiHqeS2bb7Vmi18Z+TYcrFPT5OLSYbkbaqV7+fg9QgKcLr4JnWhn1VqS8WnCrDC8JtgUlOmZz9iWFPjs8xGI17jyg7pvlNujvtdvNf5q0Rv+0oIOGudg6xkFJuBWmY8PUgzPaVt50HiCKz04q1LJR9K3lKqZoebUHxdnh7QUu/NmPN8YoNxcDm7KmnoqWkcNOGhgV6L6KEXpD+2QxDyQXxB9of5jQ83t4YrPo8bBrVmTBHA+ELse6JhT1M/KG8PSNMpv4ETWmxnsi8vuaoyleMrwdJA4wM3spd1yY1csaWk8dGvEy/EE9D3/s14uNp0y0gCqqellvul/y2RmngiGW/C8ECKPaceuBjdVndBr8vmTkvfeGf++k6dimaB3XtxvEbTtGpEDWbTXmuqtbl4HcYPCs7ZChLtgsdWqHCa+SCbCQTUbmMR+4Dwv4B0JNyh9MhJL4m6Bde39Ikvf2+r0xA/iw2ktdpCUEtZhlqmaOKh8SndVZK3sSKfYD4DguoOQP41FvP3XxQnyCttsnqecSpz+6k+K+Z7yz2SWEWKaP7zhk7tP5sSPf8q/34gcPUrnv3oSHiEDof8tIT4LN/+i6/o8lBKRRZi3WVt9zAI+CPPJKCpElhMwElFh5BCoweJHM5jBFNqNXv6eMVaxePMT7vVIrNRsZCXZK1xMdN303ohVmdreprSHQZg7zYcrIMpQU+57R8Nf5fxhGg4JM4DlH/IkhrwtbaF5KPtNgIAf7GKDgbqhwm8UhSz4Yi25QzStliAOO1X0X6Uw9cW84mdXOdvXjsM4j0obo1GXBoE7x5FOJ31YJymG16XCkF6NDMI4CbB8qTTTbGJ3YctTZ+LVjqeaKixSNPr+dq80sV5oSVS5D/oPCo+gg4dLS2dpE9R8C9VlQQSWEt8ul2PjX0RnPYoJhwoQv//k7e0mZfe5kcCYUfuGTqqtnL2nX8NGMx4nGAF+rkI47MM4UAsWS29n6fNbvQG9vy8H6IysczXUzhnNQrVsXjfUBN4oOdsv+51d2MUYtMNLwiAh9njzIjPOaYsnAAe6O4zG/wDK6pSTOJW/ayybhYEODWGNkISkEY992HwFcXWHftEygZPOPXuFaNXRRuZPMiXcJSrshzC1QTd3dzUOO0xjewCb3kfG9MYApELPSP7f233p5sBX+jVTpyT6JdWbKcQXUKwZU2NYYJ6K21PV9benpYdbk1UU1nDHErbq+Merqclj3aPLULbNFMAGP06RlDi3tmCy5gG1/AjvD7K6xe5gd8j3x90/85wKRAWZEA1cCrc4lXxl4lCCjBOUc5FDBlj4ryW8/+uPkDBskeMoFoRO+GXZS1TVOfIzAIhdV0UqGlhOU43j30QnOm+XGzQszcW1yxlN2Ld5ooklkqSMnYXzeZhsvHGdKeIqJGyOZuTFCkcD9paiHI5/qhcYgmTxDEp8qAoHzwrUVKVIg7QZPPYG0q+dtGEExOADPZExpl+ul4mWzc7TctOCQ7Ba4kWU7XuSakMh1KSs+8G+er3eDvUc7T9F4URXLSkRjXURj0ATOdvAJuyYZzRgc7UOOfMJEMI+9a6uhSuK2RdCLXPZn2xxljAY0FYC7JY7crkKaSx0zv7NoIWy1EHeHje3hI3gTK28UUF01VXxWwS22OASnhYSC+YVN81JIBkwgtGeReb6uMXYrF6K0fNFocvtrgmTFhFDRzZNLKXDQUTc5VococFe2GbWI4LBNz+cp6LnQ7pzVXQ4I5ToZ2GDX+hrBWoVrAjfX1ezFr/eTEVTQJF0/+C0Qmjo9wikMJN5IkprN9W1fuColBG0TJgrplbZWmRwv3ehMC7q/MLMqfjQJQT42/rZO8tKMV3UlzYmRhf1rKhEXUKq0kfSm5y+kwCbUUEiKPLqU4xC8iyuiX4mfI4IsXRBDhJYIQSqKwQmW/uQ0GLHatIZAsSO8EfYew0GG4XaJs4A4St/sEn1iTED+6ZH2fKmFlsmwjm46hu3B0pq0/OTTrPZezYIGvLAJo9WWkU6vWUNHExovDwKggK1yQZhCKfw9P7C0YJp7gMd05tmUOWqf59ul+sZHrk5F0CmDp8S2vVtF/QVyibGWDf+b166DYQ+3jaaXZho4OGNIH3dSoec3pHy3v6yEbEbeMfIV0x8gZo+KRH6PIk3ci8bhCmQr+nHYL4BMzkzv1qi49pTl2gGZ2KBhGE/C2Ikrk406kQATbJKKsIfkzIsrkYfvTydHAMfbzgKwU6vVhu2/uJwXZrJ0zOFOg+5QB/igQCFLlvcA6ZnwvwOJMR/n5NxV6lQMxm02RGVO42K+z7S1FzEcBjXtloB2fz3TkOAEerdpR4ibG9axf/oVy4ezt6da+GLmQYv89wkxcBKxjqMkQOoqkIL2d7LAvG2rXwdFpFVlnaD65m7VRsgFb2AMn/uOh6Zz0V+SSwxeh/VSGpdABOuqeyGzy1I+O7atJOmJn6OFpOjGRgLHl2/muZ/TjdG3inHpPp4cVjm4JV5EY5Raq2f64n5TR6yn4SIivGdkTRZpprPjETYGHOhtpteEZdAXA5l0YajuOtZ+pzQUGtg1ZThS5pKwJIi6QjFXgzgXC06I1iT+65yt2ng5HilGABQZzZKBfYGpKW0h+ljjINmkv2gNDtCHh5zHCjUhkoYHh7T+/WerENEt6J8MdVT65NEcw5iy/QMyHyRVL3EmcHLnmYCBxEjeYlDLPY1CBST62L5sH9PZWS+ZSOL4iPQ/ZKgofthCANn4L4RPJLlIagUge91fUQv9MwFiVEvGzPMQKIMLTAwNDKgLRyxsO6IU8sQrqEg979UQjNcq8jBnUyfFu1oHUcSmNbuT9cEb14zc804/FqnjlNrVbne0r5ABwsM658h1DJA/r0kegWkO6nYUIUHofiWOik7L8nN3bbPN3T7rZRgPnd+nbgIbJADd9kTglOHSTJdt7+bppNwI0d5TlBBiYNQu/XAWq1BM1syQiwxJ5JCPDuaDjxF5hWR9OqF8yGKZRy+xGq6ZOJ9PluZT30NsYfVH4Wqqp2THsjmkRo4wruBTlZ9LWZafx52RKcGS1g987XgC6JByl94zsHD4UXs82DWW4hq04c0qjCtWoe8XrG26nLmjod5QSYuKuWyJNaRKKNvNfs8YlLB1R/VZhu66gAS16Dwls1lZO33nLtUY0W2gbKRlOeeEjVwFTSQxIDy3sRbKcVf9H90ZcVjNHxbEfKjXJL6j4kUyizYmDayvYJYaFisEpWgTpIfJL2vO8JP/SRwtDitnCXt9QvmBAqj/j4PAJRwRDy42x4pSyVxJVkgspa50VAQ6nh+jxYsmdko4guiMVs3lBD/EIdqqkCLZihTh2gqKNvmOP/0pzXL9fC0NBntKffhMgIjAA1+yEEIWpyet9VsSvop8pCFoe3hfKIx/4FqCcZGOaiPBjgIhFSOfe8jOo5cIk6V+fU5KEquDK5B6IXwPhLfX43bV9bh1XjMR8VPDeeKiuTcs4Q7ouuQemd2h7w9G4oJ1ZvNFUswvgsjENN850YSgKnbzv1oUez3d7vPSkIq+0RWBeMU5d2dBxmVRJbhpnIq5MAltr8xYe3mEMilFcXv8XgJ6ig0SWMiqrDp52prcK0mNVejo+i4ncPtrFp6CHHvN+twqr6y3+gzogBjtsbZ5iHnWBIpLxfapyI3ywRY82Q2g10QDdGX0Fr7MzlXVAckJJNqsWVcdm/QtHbIlvyx2H7STyZCo7gjQ0xxsddwUX3XdBsywEPJfB3Q5Ihi2pJBR4EMGC64LnGX8KK4/9CD9nOxRJfwvQBeBtck2ZFgeaOS6iyZYCsC1IcO746s+9ohEdcZhWtqeIAgt6/Cb8sNb2+z+zwoObhPCeDbR5VyEdlqZ9zxv3iW4AyCpLAgEMWHNGoMYik+23l2ff5r5HWywyuyHRJnKYeWbK/0i3lRsGRTldu0E29T9stALhEebvMWt4P3JoDqlPl6OxOmH1s58zE0vA6Ecf0LiHPoAzkwugYq7ZVpIrMB8IfWf9L9qp/YwoIrnnWlpW0ljNZAYU7sWPix8/YhAgcn1CTq6b8KRUBT5vyma9bhjAj8HN/qB6goOwhQIvTbC7vas8mZTQaFtaOw1Kp3XrbOoQTja6/E8gQX4LXfovOpTiHPV+6ooEN0Q5iOVHAt7Ov/x4eAlz4aFJJFEWfPEP8Fxg4kLtEYhA1u1ebKKKiET1FGXiPHiN2+ysDijL3FucUWyPvQ90bHvRD4paooIEGN6bhYzx76Df15k2ye7EQG5Bn4JKPENQUZ70dVfI8OQR2qRfGXl/BGS3JUvCBizqx26AuObSj0XHAfsEgdt6OZXwZzq+J+400uCMM7Npjquopoo5x9zEnU917eZA+TUVuEVOHxl/umicG9pFnFHfJ91xABRGQtP0jJH0dYOJOW2KK2a8vKpveYhHnzvAbM+hmoP0UBSxfwTERLA/2ioAXTJIS2ERIdcGE7ES9hnv8/8n/+KP3jkH4eWW1/fFGMMRAzEnn8n0ha84DdItT0yTS8kmvM9onhqIbwjGOMZHDuQaPPQL2e7Tm4XBEcyiri2yPsez7uDKDOXrJgmoXPQZfDfQ0WRbqNbiyHWR1+GRFyGiS+ILhZ4Ek19/caIFNQkpoGojQc6VswjUWhb8Qv6u7PPJPNJaSVwL91vTrWFhVFWXKhyGdKvFmL3zMrp5QUAJOLlJI8oRGUiIuB6Kt/q9fUMM8EQo3letZfYadouwUDWjqVQ3RCa1aiKiB4cc4tArJRwIiqKd0Y5MpXV0QW+SzZIc9iQIaLjg4pcTqW8h9+Xb+Z1BaeLxyByfzXBNx7MrW9t7jbEgsvZopfDx+xVuyG/PJU3rLwAoQ8Y2x4yrvEBmYXerjIGW2xlD6tMxW51zbHv635CWEUwkoyTKJQMP+rCYoFuVClRXrLcmh1/nK6Lcz7nuaKQygRV1tiM8zTtL/lpjcbzgeHdPJMo8CmVBLTMzBXARkjvmBTNQXoLjsSHU/Ib0+yVBSKdthSZDPntvNq17eVJChbBMaqKVEm5O3W6B8bxeC2pE0MycHVMCYEG7jizK9wKtA8u3UhZa5I+4kBpGe6m654Tu6hY4jiSIlp8D2sowXB/ox/3htMoeQBEbHndZXYfqjYYN1YwqAU+dW//xICAHUgxk6FfkYPaKIauNkJH4Lv69kSPxFggmlxSO4I7irSSS2Gt/B3ZNfsCZvZOj28qIxkZ5Y9uve+STnHAIj+MKGInV7IsmLuT3nSLWJy6J4FL7qi+ZHTkhfSjFDGg8Xp6Naef8yL6YgEYc5JTSuzFPVxxdChZoyUMFhRAm96wMYNTYEXlGvqHsXUqNlcHWZKJDv3+PNVQBMjIPN3JKycOURqodUL1DhfTJGALidaAavMLKxXzTtyMR8HESk9/FsnchuR11DTc5VMVJVuiNJD61gxAy5WFa1R52QqVYIOXPMbiT2/97peB/KtYPTSOqqabyFBDZHYVyhq82bH3/e03itnzfvU9BCdcPZCBs4jlE2tC3UNLRexN7HreGfU7LWrsgdqQ8FOr+DlHmvfd6DRUNSCDmqGuaGBn5aeYpgQ3BNhjU8nyl4rnKVJI2ZXJLSNNsjcrm8JFHFK2i6dwYaquA4BXEDmHs1+uUuWGNd69RoFjZhQ2Z+s3WsIYXgnT/KvHxlfrhRsQ4jg/5UzHLWICYhy8lkKeVp/T9rCw5WFs5ga4+PWEgrdn+X9BIJWh3LmR1xnN80ysmrfCITEohGEumWO0Wc/J9CCf5SM8eTWv3DUH/8bFzYkOhyBzddaA240AEYx86ut5KO+Kvu/n1N1ZuJGxy3tBBTorAtwjsWJROjHZsdJjvKMaIM4ILOXnbK0A5s/6b4vW64p/39THnebkUJ7agsCznzCI9nW4LyrW7AHkW3g+peCQdjTMdGhWuyW74EU4qkg7SC/d3xn2cEIqfC2hzUHw43KhNouavg+jgHuc3YSEqolpY63BcESMh/I/POoPXgEb+y+m3aGtmOT2lCX+LWwY4bUi6hepTz58Kim+pVEK26OFtqYdRPYGxqoHrhXhC6vdcQ/1qDTj5Gd/pEaes6kYByfJb7+fQ/cquVn5BYsVviq4R81Qj7ZiFdImvxAqNOIaSovhwN/WaMzpSxwbLvkwtkOselPfEGlkEIOgnP5OWyF3TTGZo5SjX2T/KXlBe17OruqhGORUdUXfUhrZsOsQSJr+aB0Q2Knu42NcYLvUWfOoZcmCWSbLs0QYOGQfQEuh62/LmhhyFHd9kkPPLN3H56wx641vFQqqrpDs7+9X8LPPy133GbMisYbLh9B2yhtOMpdfdr2E5FFXrKTnN1g34hczes8XRVGK3MPjyXkARFahu73tSe1qVzFFC15VKvKKB1Ci6LRaLCAZpmW+wMp3956VNgP9ruTWbsuLUPb2/dF6/RXRpEQBsd6Uaa6JW2Loq6DCn8M6YVH35mTqNbagYc/urcHgGLZF84c1EKYG6rWc6HwRF/uf/yqxl9WjJJGgAzJ3CvmVM0GcyjIrPs86//VszPau19zspkVxxk4FcjW9psh4p0h+mVc9nycx8lQAlk0D40H7byclXOHi2V225kl5noELOXSwYZwh/Cb88+YFZIqx1A6Xr/utxkLz0rDT7+vxm4Snqpy5VRgDHPb/aEagSBCI93VIIX9BHelhBli+jLlVK5ULqNa/4ClY0EXojbKhqiSC7ZKOy13x958I8sK0UpRmWyf4CIwKKXCWB9iF8zKn/CqtN02CtV8PT9LQRmAE2AH+v0jTSxo6WBDWAsL7LvvP0mEYvC1udObLyNb756NtMyfSeqAVNRg85WQ6od9Kvjr9HWEziH/17+URZHT+Kc97VlKZ2BUPPDATgINKye4RVgjXGZV5SjTgYev+MR+c32cWBjY0OyIXPnGY9/uRp4Po4kzEQBc3GWtJLLy87uTZdILcMT1JhoRbMyns7ZO4QAEOcBdH8lySOyyjEPAwgtNTGOwX32/KedzEGjy9uIfb/vHmJi6yJY8FfART9L4VEuRStjY4ftQmrtiJvzWEjzkwB+djwb5Rz6qgio0J7VLfXOFcN9o/pkV0+77VXisMucHx+E94UW4L1/qOY1//0xZKPiZezDAjHtOJrAoqv/evWXklgvqAMHHsY1OGe+7X17+l134W2/emcB9ZZ8MN2KJ+gHIfDT4LO/RXs8J2Rcuydyslol5E0cYhSZ4Zslc08J0m+mLBJszFnGattWOR6dfV+j37NI82mZYIaXFssQyGe2Xn9Zt5AACEZYFgdGZ6LZH5u6wYV3t8Wcu5uHzptRkIivZJNn5RVaFcg9r0o+uF0SVIQ1PAKHtsM17M821dXF6agjjnMFuceTVyMQh7qyiXCEB/RZpIE/qbzpRjQgH0+pV1aemKmsuZ8KuzQo3kTHuc7q7rKXDNjWkGfujZUz3eK6g8mJ1A3ICe7/LaiJ5t3xjOTxhMuPZ4JGO6QYcIMf8CEM+fyQXnh19g4stcRu5wzunbCqQNU7BUnP3nMSf4GR6BvVuw3zqu4pGvuB81LHFr3jhS1H5bpLZrinHuPmJ0rmLTj+wog61vjtMLNUsrZgk+B6Zfc3ef7J6q2A76Wwk+Ia6Fq3qyAXyFKzmkc2ltMo2Svb9MZNUPTK9M7PqGX6OmWA8QLAmrItdFBIdUCQnvK4fJZBM32RI/E1KEdN0VVAs5/AaztCPi14J0yn0vwnsr3I9/zFSP4c8LkS9ymWG2o+Z26LcgfL2NZ1O1eaYSdy4iAUOkr7CqSb2m0jLcD5ZBddVguvetPS2Y2x3UNR8w3l2nePFd3xXN2R/2jwB8MxuIM3d1USS/ua3jZ0xK5Ubi7zNGod0YfPv3N8MnLgUbT4m0R2OCy53kaai3qeUJaH/GoSzWmJbatMYTml++xmJqIIC7NRGvciHbVh9mjAco73JQihRoQ5ldlOpKtbFB6/xUahx5wQFYuMf0d9nbEY5JUpfcWM+LZvoUNWz6RtCNk2ATwnTUOUdWYXgIU7HRzHor7DY9gNuLYoQlehZnQQlwMOuc0ZLqsS+bA/8ZF8mMuDzL73GcClHkC5WZ7ZzsCZKqouqSRCRv3+5+Wmu81+LZWXCY36EmCcXGPHnZqpRy0/CVvyA/tQzYTVVvtiAw48rk9O6WhSefiN4h10czkdMcwbMi/PJhz8eTV0y5IiFx+aYIJsK4L7UdLV98pfO4xqWXWwqivoxoOZtQ6JTfFy4Z7DQUn6ctZFPVvaLChbh7HvA6dZ4HoI6aED+OpOGC0BCB0NoM9ktRFH+nJIXC0tlZm62xDdTn+Uph37JjcTJvqxUu7GRr7TVAHU4tK1tSN2fzo8SuuPPK5vWvO6O0x+VNGbd2W9SSwNVZ8QINjcA68CYMXbmiWho4wBQE8TV7z7JLK5Bd/ajjh8O8JPOXp1fouaGMg+giWL6ZhrGr4iU6XJ1rmp7P2z8XfcCFDQfTmPIq0eBalvU7D0JtC0/dQQXb7udMOBKpQUTGx4qmFdxUoUIu0m7IyIjDrTxgyUd5rKOtlfLe+tEFDcy8wWgyvd2q8PkFkCLxOhttA45sTYgPorRhbPMSJecySh5vK8T1Q8eIr7M20jF1PA1FxrnWtDNQ5i1PNKJ7kuNXhmQ6bg/3crc9W/65imBn/1G/2toLVHfgFUbSbgr0z4nt8pE+xqgS4QrwB/wqz/j2902SLRrbGgg/f11gY0lGNXBhFzisvoWOAXZpib2ahqR2BwmKjjt0R4SipzaZys8hBXsxFncJRYHGDygCSYMgYGABsR2EVKLn5fwl1Hzcwt8skwX+2FAHrsNB8faxSmkPMSHmc8GE14wb14I22tiK4lQCpBVXqzlhFD2K0+9SYMwzILKuWVzy6uY9QZdsLD7NpSI5x6Du7jMs4laMRbqEBUSsCvliAxGUn4xhEvZT/HpSoKKM/9WYRelfM0Mwbjthe8YaKMTfM6I8/W7Lc0qV3sbvdptmf8fNNAdWayEq2EZjFzv18Lc26hGP/jNO76+N7EB00uTCHcuDUwBcbqIsjeyvOyorzX4TTSPpDJ8g3oqHAP4rzOWrzz0KlnApO28m9TnlGuW/blf/GwD+w0sOig2+77yv+Sdo7TLQAdkbXNiaz9J1EQRZymbRBtTs7dW7FyRPVTNY8ID9NlAeY2Dw125NOtwAusnW7NEqRFO9qKswkaI+KY3PPxVRtMiPDcUmG8pEBtTah6waXBPY0z/s5Q5Xv357X5q9RYXyIK3JmC4e+TZ9nzO29+/TX56khk1qRzpklzCNIeliiEolGYJ9lKz+foh1pCOMPgXuZ3nqGsDGabcwgk6u29S4XtjIwnzKaul9IMUtsqIfBLsREugVh5QsJV3cCeAwRX2liiPJ1VfXAywM6LlVIPFvtsl+1AHaVUeRMTMcukGujbJLB0yYBWGD7q9POqp9PTAdoiivOM26YkmRgdZtiLDwg+osMqZEQQNy5iv4nmFrIlrc+ccOZoPAKYEr6oOeYWoxvmGaBh+yDigjJXFJwzehGV9tZ4FqRipNOZxbPQRLCQq0PkscIMFmGNirqA77FVr1+9FfeeS2jCzxC5sFsuoCkbH6UBATOTpunyQYqLeX9cYK+0tnj6FY8I7ivjQbp7ntSRIQg9vfdGWmuJokkBUCJe3TElUKXtr117zHnc8WRBXzZTYLTiysLtPfEQJrX0uglZYHw7je9LHWvxNuYffC++8ubRVzmFCvNHh1DvcvbwB+TaKbZwugaorKM8g4WXlJKjxL3oJjj8RvjT42KyNK+uMG5fCr8L0f7J1JsLmpWNOpqCH6U3aL/Ci6HASfb75/28lI93ehJLxFmy4q93ciLk+r4z6Dx6tkI7Z78IYmhk0Fts75BxMnzotfG+qNKrAXEgsYL+Obi0Gcd7t67RGe75hAKm2lnvfmiq32oHYxwmJsFP6NF5P8A/OLlE5prAjc1R9jFrtNqK1O31nWs9Afv8qwAaMmVx5MANvJD5nAcqBk1Esng0LjvTIZcbl5BHNcmOfrPJq37HYyJqWtHs90tpJw1bnOORGVxM25iBxO5InusIaCkPWIGn+XULzRoFKS/HjFOeZPkuIXLXlYY/rnJJRpUhwYd+i1bCo3jyWPpR9u3n1R4V0Xf3n/RPZh36sZYOqGA6HX5uUsCKnEZCaL+X2DHsEZ4HIWLDFdWrEdGxMwgwjegD2u1SjljXjR0jz2KgHVYGJBZ1H3Qpc1mCmlYNG5Pu5hd5Y15/TxIjITsFTXM9lZiuGg/ZRKJDJvw071FbE1YByXwJo0rIApYKrlfP9aoy4lrhEq+nOeRslssPamQpvwqT8Bev42gN9RUf4qi5DLQ5UyBfDt0s7hX2XUZVVN2nQIn/ba939XC6yKYvaYM8ww39NToCB8I0XqbeysEL836hCw/NQLZSlXF26LvCNlAbrt20pzdmIZZtMtQWHCTKCrbs1US89hksRmYiFjD9dCU/tLC9d2587lDxPNR9Z+B0E/y4jFtN3MSE5AWn5njkUqd4bIzYrgP6C64OXNhCVy3HaRNVL50fK2vkt8rg2AKcmSRG0zvCMrv8bOPbD1l8/HSg2tLRuoSz5mumFBJ/fXv8SjxlmafFcYT2ZLJJUMopN988eMu4zIDGZHvaUjzCLYZTT3G620FMbbOa4hcZ4ghVdCX7s4DMxGWD2vQOqz+x7Nk+8iJXvA8ogUCK/h8dpHVntwQlYZFHarvMrWlNRACDsqTvwsdoBqVA8CX9ZGymWNlFqDhcmSN6Kn9DtHlwqaB6zMAhTN9LubR+83AjIyJnBQIBBNx0Ra9bhXSfjH5GGO5ghzdEhgAzRQdaT7WpFwDdYUMMXqsQ5Be1FuBaaWLtDBbByJM360+xkzqnGnq5FCLWyqPSdf3Hr3QSkJIPmxw2KF+KqnsY3cBa9Tk6jYhWt/5uSXESrQ6YBMp25Z3fsPy2PHsSp3yf7gnJi2JUNPlW9BaSc5cSPf0Czshnw7rsEI9r71TsUoWnfxqbScNscoqfC979Q6AHxKp6h+q3mI6g0nftQWz4hb/JGSH7mufwiax4yEEV7kR0MmLWN2GTF5EP8WDCtFuv7Q1TgoYyMfL67mYRSdV0GJBhDNoVW1yC0veMRcW63kOWl0iZ85xeG5ZEQyWZw2WOt76SxCi1AT8QDEZztOj/vncvf+Fqwo11IklEsdpUCDJzQID/2HMx2UN1yp4Bm9Zt0xy4bLvPw5968XUjcheuDTFIt0l8h+t0lzrAq1botSlFZALaDRp6Qw/f/r7qXZrIUTRdgGPPyM3eqhrfmDx1LYlQpccStw8jgFw73Uzomiei+AtuhGZqoSGJ6cYMt8NEW8T8o/x+HwVf2yVc5pYjoIhuBFOSe2lLj1faVecVgHLHlCy9dvPoxnYFVJF+2Wv/qABetRV9KL3O51541NtYmXSfY3daWELltXp8ncXOFXwxV6GE3GQoQhQgKIj2UatT6cH9EEHLoCXenqM+68gunvlYgy1HsNoNowH/SrbNgClW94ZDyJS+QwjR8NXOKkyP8lkjxX7BGvWW42t7s9GIUZ4obcFjimXf5n6lFEUGmniY/mKKqFcvYJxVy+MPMrIvSdFD+mmw3YGqm4zI8gN6kMW3gj0Q0RmjQWz8m9+Vu56FNzzGGYpIlUeip1FaEzJQjj7b0Jid0iu5XgswuepT0TW+IeOxPhSVTKIaahyVJ4hxopxeFGa37+TTMWLI3Oz7ySe5l1hL7BcsVdfHEEHQjcgj2+qJHRZ3a6t5h2xRBMcEUXs5ZEt2H0Ufwpe+yTNI9mkujFUJUZuQ+usCVRFlLgPc+4yRSGdeOw2vvWuZuZjoAQC8XHkIF1YzfsiZ19FT7M/q2xukFZyAAk5Auq10OnL8Z4JNy8tQxZgqSd89qrXzGBCWcs8HOQHcVb0zI2VqoIS1PSFE4uV/RCAjvtfBuzs7i5hq2o9aWiecEPPv1AGa7weclzb5NGlSpqYOEf5CqoLq3H6b0fyAzjEgqrckCOk3TDalek6LzMc+e3aIx7x/R6DmhPJf8oZjSpvHy1fgH2HqxMW250XD6LKeoakwp7OOCJsmiBdG5hgzPuYJ9kRjOLoV8dkRUlsOkapCWMqPBbhEwPjThpcYZf1ShaQ50Gele4nktu7bScB3BlmlLkQeLfwhDIePsDZu3V1EOC+TSg457rrlPXwwYfSJpSnKE6p6naRGuc2kVQgYd3IvbU3+xzmNth01nH1iiEAb7W1guBneKoTXQLlbMyRxKy/4slGt1LPPrszIfBMcP1bTbR5Dn6yJjnyjje84zDctCXbXvxRs7ZnhZKCpIQUTxki0YsVIGRfDuuQCSMRv+QDxeIDaw7cUwxbtzZBzYRsPzf8AFDNIO6QQfSBxzW04GCCa/2IHiNGh80G/wMmcP9jh3C1yMT3j33G5YXAgcpxoZe30/YSgsk6URhXfhKny+3qTfxOlxtFTpMeBvb5FUZAR7tZZWXwcpqloRg8Zcd9SPefgI7tN8WH5vczzemOM3TgT8FCnOl2XWC9Yq0RM5kEkVhB/FJMJU7zHU8pHsMy2tOQ7i3NXa0vHA4wGjpGSxscXR9IrLOptVNqjvrK/qH7I7htXk8zDr6koHE6S6SAn6Xnn4lHva3qT4Biiem/YTQ2d6a1vP32cfi0ho1VTNRWtwUSrqUU5Qgd03kTL8ZZ6JSuQ9X4I24Par/JC7hkUabFlEh+drFjpn+laotzDoPUQEPUYGUTCJcEuepefwTF4kSMEUmbZHXBQzKhIWBjvFckC/6xcQq8XT4T7RtdaqlnwCtBHR7EsL6SXW9cjEkfakQ+F/6zH1YfTe2eGQuKg3HHT1gle8NRDpj8pu8xo/eG87keA02NdycU022DNc4Es2c03zgje0fLxcTIWsXe8E9Iu/anwIl5x7Yuv4JVqrX6MCnHk4ONJDEWy3l3ePWkFwU8qLpt0JMIhr+K351cVHrYorVcvVIobRWWD3pbsr8Sa+M9X4TyFJyCn1ZvZKwaVUd16VGvmHVlv4zs+YHUE3UpRWr5oIImSk0MizquiMixUFIIyly/mB91HCgKB5ljTk2utZ64/pO0ZLPwPvPbMGQlgg4zonmgScwI19Ny27phDpVn4blr/bdYR1ZXxzBIvrYCWp3DA+DkIjGQp+T9fSHvVAjbFDzOnwpP3vKyiNxriN1sUW/lalE3zPH2nX8AMeFxc94Df9tJEhDWgDwSzrUJOwuIqGYtXx37Eff1NeOvtd9rB13uvVNWDiDxlYnGf+G7YpTVpiKK0fHscW0PA0OtU6a/BREEPeoU4GYyq3pt/kXmF0Dl0/z6sI1oyJJr0ijMPeXiJISsRrlgvhmWrblb4P/5lLTiz0P7ll/DDDbkBj/R6vs6fNR6xY9auqTagdjZZI576TbpOR+VWRfPvm7kjsCC3UCUGQM8XWNu/h9hiM8jb9kxu7qzl8r1oTj7HJhOqWXEO/okplZkXixwXf7Wn7ognPI8ff0LOSR1TNMNsPdnF/A2BJW9QZ+L/1d/JiFa+heFzKgdlIEV1lG+CeMwROSPJM0WUYKpu6jSj8nuR500bYnk7SuPvv/tgzLsHIJHh5trAbujZ8TGmMvCIlR0xCz8lNLnc95dc6xzAZq6vGrRSrcM6iP549kg+0ukZ78Cd0FNACqaXu1voOJwhWgXHAhIkdjdbuFykB6In3c5Kp3+UnaJehVhUoX3fZAlJzbFUdWBaBuPUBPYREFUVF/TN6wbFVt/nmv4HSCnuCSiGPabpINXFAFBFkPcn1MxnQ3MHhkd1x8Cb2FE+1s58MBJhOtQaU5pO33wkeSHuWRNihL4JO54mUgjCtQG8uH+3riIQuWnx5Qpf9IKxEEIYO84PqusL0pZRA/tcftXv2HaW3I0PTVmgGXL5H/ow1nByKpSfoUUl+tPL1KA+YjHALREcdFyIqMHMqSnnfYsA5xo8O3lAHYm12lk943lHWhwgIUiBBa9Og4rPNap6HNU+JRoALVypXhLClgUnA7OjFvOoNILGd3lLK8Q92f0mlQP18pOPnb74X3JYdh9phYdLDloUvPUO3XfsuDr1UddenTqknrrzTJmTxvH4nZI9aRTampCKvCBLWcMpEGcO2T2Du5z9ZXjCnBvBdi869QE6UuY70K/V23K+uNnpJ6pAMhWJDSY3teKqy1wUoBeoKWhjCUiKfhTmTnpMu8hcnQ7dQvM53epy7KblNH5SvJoMt7YOkGx73Vo2aghuKGPvbK8v31Ce1AzqhqErpeUb8P40Dc51h4U2f+tEWotvvhrvevhCCG7lUHerNmgckdZIXFznMASTGmczYZytaaKyF7pMt7hNMNFLQu52KT4dtIoKC/9a1A8eK4f9zLM+oLff9sWrBgKzzK1mVoXURuZ34e2wdVLeJXJn+fC1WxWGfWyKmW14OLjEW3JTXrecJ0b/E6hEU0DguF99ZQXYu+2AKrmn+/9AFt6Sq69E2kOAF8pEeE8xwc33PWRvVqoRjG81o2hRsF+HKou1gNiIAyffOBpcfu8OVHw54qotO+NiZboOtids1q6qpQLtKiY5jHwp9SD1pLcP8wF+sR2Mpz6ITwCTxqSLl9HCrxDJtSijtjm1m3X9viCw38dWdwWS6F4F9PsLYUjFvlCiFSR09CzRn3E5kjffg4jbpqQz4DD5mIsNRuiaMZ0zWhsH/GkQxjgKx91X7ucovgdSLjkNKE0KzI8w9gdz6B5OOV0zyaIpfrPvE/kUPH4v08nVayB9Es6sC/NFzWRvmxqW86dRi8N2H/hD6Jk/0FXDYzy254P1XohiQhamAR1TqsLnqltrhI64+iTPxR5Il21Fk9h9YTsxF4iD7Oyd8szzes64OhKdEtS8DcNNPgRvdRt+QgkLLryHeWveVS3EZzTagfD9EkJ0urCBJa+l4rlHSGYL7Bdve4KPixwPVeVUPyK5idpg2JRJ10yMZgoabSyAvaQ1YPJQ4+0dHdp1/9HCSM5aS7ZRODG5gBDzR5e1cWDkxB3LWKBQE1m7cNcB4YGNG1ehqGk0xBcbMIbBb5gCrGElN9z0fGpn8XCnr6r6LdFnQ0axqvB99vx0bi1Q6jbuVx/CN+Fr7X7z80OV4URBaafeQX0xRxtNLZyY2Vy9frdNRn8fTSmmFYBc6NIvjUmSzPgEX4hf2w7SQKAAdnMFHE/GUROQkFEz3XRAp0w4BN/2gtP1NrMt/YXgfoWfi7tIMhhD1K2Z/QL6FwRBj4QLcxeBWErNzRL7aImaGnbZ0EFD/KVdFLh4Pp4O1tUw/iyfe0e0/w6iZu5gN4vF5ymNHNijaP8MGE+HSwCeHCGwFN7oghG0LmrVGDupZaszWhv4Ep1GkgSS7GVUylnVhIhVsbADCWLcAK7W8RS+Tl3bykQOwqdPeXiKf+EbeONeK+pEm776oF0COwXG0MtE7LI4Yc8sTdWLIiKOzQ2Q7XnSwEvr3q9BsOmvn68guFJDnzMksbDHzWr2nVw92wBb2DxX5smTOPHv8qMP8ESdngwYiSw1UPx/2PpMOPDoOFi4+xSE7MfnS/am9T0e9VaPnZkHmOEfectjKNBgQdIul6qS+7tVCkR0dyaNwinTs9s2rF1wduv1eoaT+Ad1TWyJ8D2Jeo7EzH0uBPpyiS864l+aRq2jRe9sdWhJqGf6PiSc5OMQg9DYkYLtdlNObf+DuC2pscRO41Q0wks73czMGIVzX0N9vGlMqebtNBVB8Ee5izYHFu9JPwZNtQHKUUVGN/K31ZobcDfUYuruSPp9zhLGpJHhjSjl8qSFPQVynsYTD13jU/XwZ4spMNeWmMRIRXGkmOq29mMepKpCuA2DB7BETfc1qQnqVTXsJn/uUtRVzXLr4/+EPYWJyoCeGJcsSQymn9Y3rWbjcdJHKDqgU8nmsDP109jogMrWjbVZDjMGqoJcxifQzdZFQZdpjbmpbLQTH/TOb6g/cVe1/rZXA6cqFX8XZdQe5fZoqrqjn5FdswIyqPf9F8Ts6xa4PfBeuwfem55T6V3v+wn+kXP4qdTvXqUZZEtZqxIEnzKkLeluZvzzPwBGtD+rwpSLqdktQFEY+N5EKePl4HcAhWs2wOH26gTNdqBQnvY9HpVNVh9uHHUvSdjoVxp44FnoHSY1KehSRqVVx2makg2j/Oc2fsCkTbFfVr4ZLlpsA3Bd1+lKmszUc5RyI6MZETzuTLmokP12FUxnoExNxHWe6/ObdJ2dcw/LjGb3LYI/Izi7yAO2UGM7AKYLuHRBFa2muIlvgF8spX3lrWDSJ/3CkcUnk6vx0ScbuglRdecCLjr2xip0EY9UJ31z5QL5s3534ZkjXJWX1mt23dOkG0HKinn4QlCwqw1p3AOpxEKHW56dr/ZjCLfGjJjsBVQIffADIccJtI+fuy6G+ZuFCZau8Cnx5kd2C1SgUHGeTOTd1MWuISbFp/CjysuMk7ejXJrc/zvR5oF+S7q5R6OYNuR4Y8AK4lJGIBfO/5/6lP8BKuZsEWhzxzndyiTaxkQdSfvPycjsbgMCpL8vw6G99DzXarPW9ZYdPW/YITORa2B43/lOP9w7ZVWGQ+dVjIkIj3Mx8ubiy9jmOSE8duUMHh/zTJ1xQVhpsq1JUwrWaJKIlYb5DVAgtezfy7j5/BpFOWL70gHco//JUPxfkwCnaeCBX7E4Cms+Z6i/+8k0lqt3pm4PVf8ocP7T/gJpFZ12SMVfVfZxRwZzvG68zBUNkaoVLM4QDjQqF6tdxDsckBZJT4I0RTLrC2o8kceGvGYablwSk9d3NLJ5P6+CKC+N/SoTW0+pDcGdplJ7F5ZuWb+lcUQCNyIzGX0te4xXXA5oL50iDw5ZpQCYjg6weHsXbKLc7kGgYtZkOst3v0fxBowc5Sa/lvZPM3oRyU2lzfs7Pqu7GBqQ1Gp3Wr3RNuXeTPUwK0HAJXjHmyKRNpByLlwbA+W/JliNv73dRStU7yaJFl/cmoKy+tyuPzSnvyTClPh/eBr0VAzTrngqNv05HAq653dVe04ubM2MGJnSn+mOcLfySC8bvdmU6GXaIqjvt4rbUR4d8+LqOpYLKw3qOew7HUE+cOQo311GyTQGraNPk8zPxCWKPNPFYPMnXlkJGOBCVEnxv6a978vmSJ0MT6EEIfx9psMqY2vuqM/ySGzmCRbh8xp+QgSL+iyVXz+WLg6bca6U9dX7TBSm6hLEYYqX8pma6CQSBFiTJrc3lkwPOt9Iq6T66AG1VNuxVHM9zPtxEUbLYz7aV4n96Obhr02whQ5Bsj8pO4srPHnYSlrb5OdIxCRDUYSgUAp1jEqVu1nv0KcwkS4s11IDIGuq+1ZZ4RiTiutJlKerkbMRggOBa6aBuxXzZziURcMW8VIgUsTIMKeq1qdplkILm3fQuQEKk4h7wl/IXCwFcZrPeqbYsbu7j9pysEGv8edpP3oeX8G1R3t40cdioEaI8nW/cd45/zu8Dx4SHJcIxn4kpBcx4X/UdCEFapIQCY1FDCpLlJdlRT/OvkSD6wE7EbM0TzQuDLHn78LRjA48P1zP2577XoYIAg6M7mm7fR1tJE4Y7TCy1uCnBnz2+/gwTKZEC5QWcd53G//5ZbZrs7mjCuSo7JcvN0OggyfAcwP2vdE3PTYatggvVodkZqs9K2NykWaWd12NgwAjJa7U4oCEhjF4NxRJ8J79rzt7iMulG0q6QoaSnse6/2V1M/fvjjRYbDm+df//ZyEM0994VY+QwlS1X4BAcHKnOmdheRljhve8ifzvduWIdjJ+B76J2wk7DhN7AXizwXafUMbthOfI4fHodhSUBqr9cpkMWbzRjDHumJk3W9vC4whNql5X2mHvI7dnmIPPWFuwLcSzgh3guzn3/BCeKxJFeXeXV1xtd8k37VqrK3XJ2J88Mxw/YlnvkirkW+3CpWltsWAoWmow/fn4Pbh2tJ8e25ccd0GQZUEcTDCrU6TBesJpoQFSdATUXfleN89IMIv+BJ/CmEJpgNTCicfEel4x9mEQFR2RAfQAjBZhKsuPovH2TGQXaH4/hBK5xjtd033ijM3ZUJhbhi4SXNJ3yWhBNtuYu1C0cegoZkLNSIYYpluPK1m0Urr+ul47cYCtejd+twOe65ZyfVoAINDupiwB0FrIhyYk/LTCxQGB7I1KkWfeHVSUArnSw96+LWJDPsBxivI9u+es915DN5N4AOW7seZo8sI2L1kzObhmlRVgy8oDR3nKoQgz7x09OOhq1sndBDZjufXEpl0IAdedFuRawQRNG0QEZjmGUBSS8dDlZhpLeWDa4RoaLTyau4JD/lzt4IBzhPmZVEpPHfd4RDRM2l6bsniSP4uvCxndkL/yfSQU1TTKeZ6aHIRl2oYPmpPcq9xGg87uO2B9RDjpu/sz1LSISv4oDi64MTefL8v7WNXBCJB7Dgm1WyiqKx01CxYaiaM6AQy4T3yWfjuA3PXQJ3Wmx2PAlx2glvtE0MZh0r74tSMaYItLgoBOZi/My0j5d4Tx9cWpx0h8qUie9rBuF3TalP/e24vzXjUaGPuo1R6MXN3PfSHWAutTN3JZ7nzMY3qPe8A7iJ2tNfijlZVh8RgI7otnfaYc0TTn8YcWmMyRh8Z6ghdzBDhcws1PWpQNEQVlV/BwKtR4VdCK0L60vFnN45PnSJ/AkjsYlUiuQI0AY1jFqRKLK/0w3fO6ZsoM6+LRdArwzAS2QIlFDY4JcHKKr8st4On/BEZaIDkkRDvx5vt4zb7xrFlzodrjnZwMCw1/ye6cJdpq+O2tXWFATVIO/BoPNm/zLUEKkLznt52KOc4RR4d/46vbRaFMyTIUOuk4AH/dUPK5grATCI0xRXiI1P2mV+QCTDK2G3UDUr/P68kgh/98535bh7nQ3B/wR8wDIdJA39hTLD2MSeGg/2n9THUiXuzzpQGY4fqYQLJGK2E06ZOgH4uHQ9m7IkfHxUrobRw3K8yOaM0yGZsXG2DsxpAA63dxpckJmDaLt1fMRO0tYXJuhjNQY6yqPY4OZ+P/irtwsqo7U6Z7+IptjKWb79fr0+lQu9LPIOZpxQrNs4BQgieEwAPRssGYHUaM3nnzIAyEiNG/v9AR2b7rwXwZgSA6JupGvZHPa63R7/Y2JyA7Awf9Kpwj9trrLvUsZrJNqvVTxjTFgA96QH0xps8WM7UiVggtcpw5OlptvbstRRxyrm2f+DVMmOY+ilGKMaNvQ32iqHaMpWv2c9p7pDGt8qXBI5PsP0hk4Wci/AS0/5OqxbXQaVuacrf2Ia2aN23wNk13uvl8r9ubi02iDbJ5JK+MrtIGa++r6vnon/dLTeVMYMxROEkAqimOH/LlWKyWVmVTGFkfBPzZQIeUoTfXQZdjK4esaDLNUWHl9hrIzc1fFqk9lKHC1+gH3JNbqPd52flXuTm+RPWT+BXIDoXB9EOgMbqF5Cyn/hEc4ZO98d1BZ0qDe9Q13XeXAzfS3ZurK0vXJjsdvCvhg89eBE0LyW8PY36TAxBd+YnXksphGT+OhKsBy3ydZJkNv3/162HnSfXHbW9JkYd/Tf4Y5Q+LNr7V3RTKLbvoMgf4rX2jyz59wIP5pW2qP6mWoHZ+arhLZi+EqJuSfO04ETI83eIAC9TvJ4tofU/VaEnpupt3NmSrjh3taYzL6fxvVgDZNpcAm2/qAgnNCTPtFRMU3vaddjG1fDQydRhPbiXs6sPwIk7RncsLRlOuUuZLKuwSLhB/s5yoiDd4+ELGH8oYHMhpOauNdHWdGALzM71WivDtRgUUeaHYf7j6EZTx2Q/QfEFOF05kGSgLqTtvLbijNVdMay1zaejSyHQG6VOgN9a9iim9HlEANNVq5scOrsGIpe5nVIuvs7FlE8qfhn//IKLeKXX6WGBiswwS+HQNplcKRFF4hRG4v8KGXgLFZ6qyscGjUonOOi5FHE3c0DIrRSmrBiq+ntEunNfbxNTCL0+oxhnWxE+ZCzpXmddglgznPJ0Hr78qOCvdb1VLbIzpucU4lpTC2BposANMvGQwbOETeFvKwzVExWZsPXoGyOVuTvoqd9b5UItyvDtMJaOe99dxDY1Wy1KvaG6sgkjPGp6mXxn23I6ay9HHJ56+5ttsuLZiq6z6zu/XquEVXZ+IUxxRwA28HQr6HcZ1SnIeJOagB1WfGat4zlEq6mrhe39VeCRAkjkh8klVSx6QM5o9sG8+QAuWjmfopH3VczChlBFe2CzgPvV3ZU841YHytQqx7jpd6JLu+8gZVsXr7HGh4ID9CYQ6AZq6vRwLK4XTLtMp8qnDfeQPWGv95ScMKx0NfVT3PUSJf3rcnWZeeS9VX4h7j+MfboSJNvPcHTbNmmTSkowj+P15Z9KIRpsGH24NaCB0PHFSdX+9r/WstEcnm9+mbKvJwCA/fZ5XcbOFz+yJDtBstRwX7gjbFkuMo5aHAzpsw6IXiCU2/O8uozc/jE1m9IblEKkr40p2p0ntI9Tcd3HSHWODXFM908bjDz97rOyOajHmu+aJwZ2W+TuPM/VWCS4ORKf0sRv2HDqcp8yfYxRhYLyluWdcRG3hgYsYfDyO6bwUT4ZVSHaLXCJjamWhfF7U6aYoRGAMtuZtdJFUxjUC9wXy80gnpoWiEMwS0m/8BDlc/nwtvLSwzCi8lcqfU/i1xg92VS0VJD133kIQaTxrQttVcpCNx47oOuP1gyALzp4mqUdBXhOMGPtzLq1QfZQXuLsTgkC5qlcw7NKzV6AXmmyKx/Uyyb5/3e0HVoM/AIVP/zi93nEfuo8+9VDn+ntRvV3xSWH5kJ6f4+PX2JCEqt2BwWhLzqx2xJNHxilGv7+HYZ06GKAuM5DQf3VoRkCh5Pd0Zu+g7MxKR3lsEmCkasj2UbG//OhPPd4qPOuwOpdsZ679hOZoKgnJmeNkvNDAaCpTNy5f2Ca5nc7hyQybh37dK+XI91qkLcYlogzXZwhB7QLvVXbzRJclWGMOQW+5Ih5aCxV+63lHAeT8yGs5L7omgFCOW3AzRbtsMIdz+LQj/PcC7Akd+yGKOVTlOPlO0mLRBN52Weuabd3P1FAuWZsmdfRZRfywHBfp6FxQaqlezLmOYX/9rfWGRzMhLB8ajIVTRkZdN2dawr85hltdQIGr8Ipx91bDt0gzscLYY/cwnERwdZLmlDsUzCzm4xR2ek/OFu/criVBq74hbh1aBX8usTyh5QMFwh8cXEy4v4DmstmwutzikcO4jO5Vu8e+NEgay9CN+cq79QYZwRVw5i50R9DhYcXL1Mt9VFmoSQmOdvidtrZ6nV5CC8mR+EKw6a3hCmMcb6t33G6fNLXlkUEqpxow2ro0xU2MllglUMlVcY0sf9EerJ16XV9bkvoWTOHrHqpx3UFno8rTm9chyWQA+hIPh9fW3RSW4fyH2lB5pdSL8PY9g0Vb0xLj9lwNTCk/7RjWtX3nIumf5xAba/52yvcaC2cEINHMOJmXZENwiGGcIpOevQwGjWPVVQ+YWoH22EAL5LweXdzY9YppUD/itx/NuFG4vdNzmY2E0tVi2WOx10IQ3niwrdfhZ/3S3y1LT4XzowO+w0wzVktu846XhZ1RpE38EnnViF4LK9J8XWRWQeg/1BokVJCAojeNhk8wUycrSkvCXHw3QfCOaas5EfB0XEjRtjWfooXUAe+B64JSOn5iMjhDw1bwu5ludMWWxawXV7xsNHebjSHpnE8rW1pCy42eGtSOckXxW+AmSSemdBPFAZ6by0XCScAhbDVNMF3fp583VaJobPsYbRpAPYHiv8OZYSUrzkn7vMQH+XMOkICiiQcofop+P79PQKV4pcsRyvHVAE6vXmWCn5ovgGev6Jip81ibD2/fJgC6PUtTR+x63Otjrj+57b6Pw76gv+duhqu6Vi2tHOuyp1Tc1phKmqO+U7pcElKr7sbc2uB3C6tny0nyuTyZ4VtZ1NNc1jWkSY5f48NDe9vWgJC+bdflzE+xSyZXVapBaw5Cq5xhsbF8TIY4SMwU40C7bOo1ErJc2rQpUxXecjqO/zehVKWprS1Qv3br3NvLwGIKC6+2vfzi8cd59UMoabACmTQ7EiIGtBIUcFK27Tw1VuQ8A89reS93qOkLqkCCaEQXH3uQLiGqVmJGGrS26BVJzqw2IqnZrugFZRPb/6NMwj6k4adPRB7diMToPvR2IewU84n6+WseQZ/gKoZM2IB/w+Wdbz1S21iBz8wbZ/INP3jh395tIsltJ9G7LUdXxXga2bnoX7nrpPE5X9gpYK9vol0CA8Etc7mW+blsTNOwZ+1FZZgBiqaLl/2q22ypoGMMwPf4pSj3nWvpcTaDx85q3P9vzMBfh77CkM4jd8ODGFqBOfSMebIQztWS4HlhhKsIJy7n5A0cVa8+LDpFnu1SEtnpSO0MOGpKWdBexX8pFMRAQlv+uQicuZ9XceYcDp14SYdb0JeA27KQ2NHFsm4TC7gzFCRKwM2PEDjkLVLs8thk03d3unQZtZweC/b/yECZdM8QZK9ngONIWJ+u6FKqRDzzqqMQduWiLPcYEP3bn0NvbVEW6FVAmBlsuzlh3OzigsO+E60oPr4nfAaUghECZuUmfij9GJnr3p2JERcdONJyLNWvhy1yScpGpZMYsyDsXqka3F+FyHWgRTw1PGmfKh4UNvGEfR7kKv2nV/JKNAkUwVgYrNA3Z3eE1CKDxSczBbV7WIbK6m+mERgAaU7cIVpIZQAiTzRDS8bkDdF1wwfbciPr3zc+yxMj3cXYqvSo671cm2uZaik/qtEiGIRr458CtASiyPfCCVevC2+RVIRZfiZOQpJGDK+QHU8xV84aflGS8vRHzwU0smWLmXZjWUqpHdy88IKny4A6QRjcUyvtyndoXyEheXrHM8EHTWgYgdOJyt7AroP1KK0uks1uF8eNLqiBZt0hOkMSeIY9QgGtKYYzttruWFeQ/rJO4wmYopRa8RB4+iXGqxQoNPNIRzLUZllZzzDlR/8mwZkejcmVEphlNYd5UdQvLjOdamF4o5L2WtVmmEWLlrwemEVcxP9f5P73DKVXeqTCbFDzIsxUVhvJiB6usdVCJpUkae+zWoxBw0t0IRlkJFwNoXDdvcui0M+y1bv13lMX2IDnjeJSYW0TVcalkeo3DG9GfDmFsoXpAG680DhnSXK8SV8ZnDz+2yKj01wR6mkU9EPhtPizoko4ts9EEJrEvUm9cM4bpZBqnhtCSTAca58RAsUf4E7ypytC7+0od1w9IFDelim1fr6hME7U5i9S4HkoBEYQPUKTMV/6HZtH+a2thHaUwoZuF8nJpH1ClM+RRP78Pv5+pCxHOT/ieO5G3ZY2otRLHBgVpT0+z+LPaHcIO2Lxbk4VP45Hyw9xpIH4SoI1VYFE7d0XDZx8nq1kXYadGQW+4+hY6W2wnzivizDaoV8BnKtvQV8eKzH+jMDXf7vT68Pb6yXdBg6vDBGbXK6HKO/zsSQwm/bKF4KSZmw9Xxhq/OYTufZBTSrdLW5JCnu6u/CCWIFN/LawymaxypEaiJLLp8ZzaUQmZpFt5vcC3RVcApMFJzKQTTzKOo52aiYs5NZarHBI/rZMv9UNsq5FQ0NK5gzbdPaEGtzhiNqqdJh7fQk3feER74w0Gt4kqxi/YaJawWLSWEES9WIv4cAP1T8lnifMbC46wFspYLJautEpOiPOHH8pltuqkMLI6LlPQ4bbmWpM+wIu7IbOvbcO73gipJYIJksCkQvQNuWxgcZnGqxl0iJ1FTb/tCjpR39/a46cI6mzJPMcGM/4BH57EBILqwccG4Nu3dF9xQGbOeQjVQG4mNtejbbMQqqcOVSgYphCbBkpAAXob+uYpdJPXkBQIdDY9ro7t9nOEjMxPblGPKAWtxKV2KjD8v+m9ChwhfYyOGl+BJT1XpFSQp7Zy/VgelqxIKLRrzi9IDmxaU7fE5thaMre0B3eu0lI196GLaSpSKHKT4XoIpOZDLaT8i4h3mbjXf44YzCTXcREIlTFDIIg4zREM3D804JVafjJiiO4bVpACU7AxH+zmID6lHuvFkgBMzHIZIQa2o/rJpDvjnsocm52TVlsc4keIw/ZFGDxvFPPXqQN7go/wtCyOow14qyPFhFD57SAWF1vdxv+IJRy8GcRBF7TIIFHHJIP3R5PcmoqcGyO7JvBiYulJxnnAYwayfFb/XdYKx4K79uj0Hgw42l1+HPUmqJ/do611KF0EmZ1xuqRSbVWFydgr/Mdyni/7ZmFSDjZDZ5bNeVWUwqIhjudtXdDuet/4w9hrm55eqM8W9di57u3KOFLv+Bexa0iwJ0mmqcssp3sWUYWLUe6YAaBnbirmIzyewR4GWAq/C2MhUutyYYh2XFnKSzVuCxK35POpGYmnCf+0N5LKMLCY4RxCpUzmw821Rr+b86yKbKAxXtTIdCqyTLGZQ4gREl4kO0UXxprMHqz7xNKSiNG5w1nztRJJpDcrTOHlH5q8/w8lGdEb3+hSNtmZlnqxUyLb13FQzLMJ6lDpLNJHyqhm+sNK1NxtjyzY5psuxzir8SgIUKsIV24TbWgnhXVl4RrYz7uFKVgByVKpQpk8t2EpqHRtAl9Bes0AHeropHFS/3U2VcoW+WwO5XKygCAM6MFyw97tEeJeWdNLWFZa2//TsXYDQjs6m0HhitP5Ml4ggHAdUwAdPHx3IWJ+K9StAGOJCFkAPWGK9iqKVmJa6Q1B/ZPlhxokDsKHKMta9bjsi3BMsGwrRyAWZ5Vzvdlaau+4svxcPkxs/C6a+5tzy2qh0G1M0k4NurtosGpq39843cRubty6GJs/Yqen6MeJHFk1rkpG1/IXzW1cXnHJ6C9eKVkWZv3TZsq4DAek/G32eWX2xlEpR5/M9c2OAsv3exKy+nfw4vP6j/5KhbQeRDrSoU1uu08It/Rot7N4h5/mYcGQtmSpCKWwCiWnvPV/5PQimCrDHpGMXUARexSB5hQcej0X/Eu7OYqkbLAOB4bilHd9kVMVYXb/cYtj7qTYr6OPKcREuMajtYTD3Ggw/VNxxYkQvWQmvAuy6xXdrU6AXgFjTYiDARywJg9yMjIGBVR4OBU91YrYaxNdSAWjQJ0Bw9gtonhO22RyqLzUKwOKU7J4fq6fT6Ye/zq/xy6p2FKGSgeQdMdRmdKpUXs0BXgSITNvYdlPnDCKXfphZaPr1h0S4AbGm5fpvxOlNSpetgRpyGkWNHynGIi/3Oirhq5Rr52mwukczyh11WicanaZSPfxi+SMTpREClLT6HgOWKsIt8mGAc4hMjQn+7NUGZUgxNaP02uWn7BfrWZ0XPYLkAjjPReYiXeG1BlyvvKOb1XyFwpLHi7oppFTZFZXwRNZCwv7nt+o7PxFfvhHy+TGAZ9GI3Pw3Mc/ZZOsCEC9ySEflHNqtFKw7y5iMr9BvggS4HdOuWwm+764/WuzMp3/FRiykOJx2ttl9f22R4Ievh5yDWC1TC784Ewv8WhxvqaS/7FvkpmAv3E0hormDsRVm6rZiF/POHnAzFsSfBd8z4bCF9vKd415/sP5PVaciTpAdhertHrSTJuRl5qiQw4giIxylPKgdPcciEwr7WFKqEHRFmZsY4TpCiWgEycJzFY9prr88rezXcdyhWN8jjUJ7oca8Uni3EaxOgLsHUqpddi9vY/ev+ORhxdNubW8LtuH+1PDIsaHHnVcuzZUtaFx1bDZiBLOKrK0+Xv69hsVburMU6lJ0J23bf/sNMmc1T+Jv1mYPmi5VROksS7i2moyO0gJqBzCIp5dLnuvm+g5uY3e6w5oahqhYEoXTR2esryVWuKmoN+LB/tvShEF9CqrEj7W9Gs/uOKVhcUKniT1wySh3kcXrqJcvIuJx9USDpj2pPgM/Zd/RdolDmMtAweHyoxacIpZAFe1GE15uBVcn5jrTVpL0Gus71XqU4twWbw2IWkl6RDG9m3NtcpVBujzGFraGMpo8Ik02KSDCAkSViXpjeVM9F30mGTmM07MWY9OSzqDNV7n2vPQo1hlkwLq9xyl8tksK6pcvmmp5Lf4rcj98UO+1ufQQE5o/niBm/ciAUC68qcn4lFdGhlTD3WlB3FJWYbsY/wimN2/u/CTOvPt8tSj4FfLwP0fgP+2C0crbRCurS5wiC6PYCH5Z1KQbBbe+hclA2NQZW0V5mH6CA9COxBBN/nQzzYswG79/FU9JSuwn5lpqYdH90EgM/Gwy7pZmmJibg1oSHc4iebiKBPSkL8Bkru6E+2zLFuZUf49GJ+OFyjseKV9vzambtuEDsjzu5hFR5TR+GTwjBt7NNoQxRbdIxUq9QeFET0PlpAo8ZM/4xh+M38vj3irZJ4YXT314sgDdckYWCKafKW9Mu18AF4l8EO63xTDd9DD4AGJ2UUpLazJpCKy9vPryxrk4ho12eY9sKM7jLBvtsJKcJCHHP8x1LpWqNMnlddAvJFrkBB+b3JBRdLa0LcTilDmDTxe4pJboaBjtPjE58Lxd6n8lNs3nBH6/5LJr1KxtjWEQ9qYru/mh9yC/jBhrsvMBIWW4regbBMuUaClP4m8Y5cx9tqp8whIfLyFpcWAc9RNFTYhI0So0VopogAMY1hqE8vh0GnigavBaERNSA2Q8vKHfIIHn41+eNRycb94D7Kb304llRu+Pv2oXFSFPLTA1v6L9fx4iPiQ3JjOUo3Kp+SMf5zlXtbnUx/3PjnGmLXKApNa/XNV3vokHyUyYg4Oq52BWvLWPS2rl+v1CS1BAErIfpd9/3ObTUPM/2/zBfMazXrGDeffsBozvglSvuHzbcOEQlSsb2g40ziRLYiTiah09LOut4qRlVuRa6supooyM5nrnO8DFSmSb00Y8c8TeXkVVnosrXT9hsyvlxTpcCclDl/uFpop40uGRC6dYg8j4gOuUCBRCUJ5JDCcfOj6Jc6tD9FTZFbRtQacgVNK+hbXx0syElm2YSEytQUx0NvGaVyJ+Dx242L7hUIi+TBoT3hc5AYItqzatuGq8ZmXRWy2djQLYiuM6idgbzEE6pj1cFmm0x8b4q+x0hgw4FBLtuLmAJTjhWZeyG3BNczDPKdc5s8hwqVIFUaYze4/QpApKYwpJba65EK33wwz6g41Lol092N7uaglJ+qMuCKaKR3c+7mef31+ycBaD1vJvArLbbkG9qK/GkvOJpH3fkPVrcZY5Mr9FAtWCUleldRB9fiHxzJN6AdHkfMZshvSBoykO2ebKGMZ76lL7zRBlSq4V89SpeCS1X5CG3bIL/+BY/w/RGcZGaISjuNEC6CFxaNRz0x8T5I46xkzaVIkhezpqQUEEy6Ln3PnNR/sfSuRsvYVysa2reARC/KjRE+GpZe/x8wCHdh/mphxqjj0hKFNc3bzfyXI6RLP1EXHplO91N+JASazJ8riORhWACZCwricA4adtEPr2okEJBSq+Dm5lhS0oP5qrghU97IMeeBKiUNvaqLmt27NdpJVhwuZa3G4zfKcomWkhb7SMTjGY7Ra7Qn+9y8ZnNnw3oBzhZE9JChkTh4wNvcN7Mw2mmo7cFdXMAkxTNjZ1xv4pJH0HDuU6oBA9K2i3/nbxpqnFIuqghuWQ2TOOHavXISmFmhv9Czi/E0DoItNRxC+yJsJJL2KSOh5LoAeYSilbRC8F2irZcE8tEM7Yvvxlgxyy1wzr0dT+oJcrcRwjpZUYDv8ZmlxXbNj2rs+GxvQkiT9Q/P7v4vPxvvjMULTecXYuQJZNDMxoyySAhy5PJN3IkdCDw29B7IHXerY7VFa2rjhMrMFu05ZMG57lSbNFImQiD2aut9JicKzQLavFAgWd3bt3QV7GPy2nlUIqGwuSyi1XBBT+9MN7E50EdnSJRbTfzJk1cWSd/zBPmpcAuN1Tz4iLTLrlul7qbQ9jpOGXcWH6xcQ45yAfhyCXFaCtHrTng/1phk14fTwNQ1Id4iz+VQ3TH9uvpyg9SE1eA9b/Gm9MCARrv3xpEyLCdziVJgW0NzOoh59mIfIx+ZgqeCGevO3dGZThewmhucYpODCgBIGmCLYH6pHSzZp3uXpithb/a5JM3e+t8y6qHB2Hs3dzwT6G8qmXILHqLWkRgcxzYoSDSghEhpR9Vt52Rd8SoAbeBXCRD0b/dDcA3wN9EgRMz5pvBNN9RD3OiGg0y5JYvpqxXVXtjCK+xnS1gS76xvu5QE8M//ydyVmgdhZFCfZ8SBXXTxrD9NUI3ZvgVFp5ArMWBu9z8RAKLXYQuxK6o8O7OP0ztBgffZTAz7J+Zo+HIbEGJNEMgSEDnWhNHmNGWH4aEUv8AOe9Aq139h8MVwK801BsHNGn+pOvG531OBUjT+DBOWOk9N2TqARkJH52ZsUMz79PFJlWLoQG/BP1Lw1kjtHeC8ZeyT5F2gGUH6uqHHDE8ohFVvnu3gfn1HsWFpZgWc=\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 5"){ + //ID=10 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 6"){ + //ID=11 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 7"){ + //ID=12 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 8"){ + //ID=13 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 9"){ + //ID=14 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 10"){ + //ID=15 + data = "{\"data\":[\"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\"]}"; + } + ///////////////////////////////////////////////// + + if (spinner2.getSelectedItem() == "start packet APA"){ + //ID=16 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 1"){ + //ID=17 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 2"){ + //ID=18 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 3"){ + //ID=19 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 4"){ + //ID=20 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 5"){ + //ID=21 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 6"){ + //ID=22 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 7"){ + //ID=23 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 8"){ + //ID=24 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 9"){ + //ID=25 + data = "{\"data\":[\"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\"]}"; + } + else if (spinner2.getSelectedItem() == "packet 10"){ + //ID=27 + data = "{\"data\":[\"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\"]}"; + } */ + + ///////////////////////////////////////////////// + + if (spinner2.getSelectedItem() == "file") { + //ID=29 + logMessage("reading file..."); + data = readFile(); + } else if (spinner2.getSelectedItem() == "wake up ARMR packet") { + //ID=28 + data = "{\"data\":[\"HwMRtRF4z0fz3Ps=\"]}"; + } else if (spinner2.getSelectedItem() == "packet 1") { + //ID=29 + data = "{\"data\":[\"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\"]}"; + } else if (spinner2.getSelectedItem() == "packet 2") { + //ID=30 + data = "{\"data\":[\"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\"]}"; + } else if (spinner2.getSelectedItem() == "packet 3") { + //ID=31 + data = "{\"data\":[\"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\"]}"; + } else if (spinner2.getSelectedItem() == "packet 4") { + //ID=32 + data = "{\"data\":[\"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\"]}"; + } else if (spinner2.getSelectedItem() == "packet 5") { + //ID=33 + data = "{\"data\":[\"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\"]}"; + } else if (spinner2.getSelectedItem() == "packet 6") { + //ID=34 + data = "{\"data\":[\"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\"]}"; + } else if (spinner2.getSelectedItem() == "packet 7") { + //ID=35 + data = "{\"data\":[\"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\"]}"; + } else if (spinner2.getSelectedItem() == "packet 8") { + //ID=36 + data = "{\"data\":[\"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\"]}"; + } else if (spinner2.getSelectedItem() == "packet 9") { + //ID=37 + data = "{\"data\":[\"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\"]}"; + } else if (spinner2.getSelectedItem() == "packet 10") { + //ID=38 + data = "{\"data\":[\"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\"]}"; + } + //policies go! + //policies(timeout, data); + + Log.i("dropdown", String.valueOf(spinner3.getSelectedItem())); + if (spinner3.getSelectedItem() == "send to cloud") { + if (data != null) { + logMessage("sending request... #" + requestCounter); + //sendEncodedSyncPDataToUrl(url, data, timeout); + new Thread(new Runnable() { + public void run() { + sendEncodedSyncPDataToUrl(url, data, timeout); + logMessage("done with request #" + requestCounter++); + } + }).start(); + } else { + logMessage("data = null, request not sent"); + } + } else if (spinner3.getSelectedItem() == "send to SYNC") { + //add text from file to header in ProxyService.java + String ptsyncPstring = null; + byte[] databytes; + Log.i(LOG_TAG, "data: " + data); + if (data != null) { + if (mBoundProxyService != null && mBoundProxyService.isSyncProxyConnected()) { + try { + String[] dataspilt4 = data.split("\""); + + //Log.i("syncp", "dataspilt4: " + dataspilt4[3]); + + databytes = dataspilt4[3].getBytes("UTF-8"); + + //Hashtable<String, Object> mhash = JsonRPCMarshaller.unmarshall(databytes); + //((Vector<String>) mhash.get(1)).get("data"); + //Base64.decode(mhash.get("data").toString(), Base64.DEFAULT); + //byte[] ptPacketforSync = assembleHeader(Base64.decode((String) mhash.get("data"), Base64.DEFAULT).length, Base64.decode((String) mhash.get("data"), Base64.DEFAULT)); + + byte[] ptPacketforSync = assembleHeader(databytes.length, databytes); + ptsyncPstring = Base64.encodeToString(ptPacketforSync, Base64.DEFAULT); + + Log.i("syncp", "ptsyncPstring: " + ptsyncPstring); + + //send to syncs + logMessage("sending to SYNC"); + EncodedSyncPData msg = new EncodedSyncPData(); + Vector<String> syncPData = new Vector<String>(); + syncPData.add(ptsyncPstring); + msg.setData(syncPData); + msg.setCorrelationID(6001); + Log.i("syncp", "msg: " + msg); + + if (mBoundProxyService != null) { + mBoundProxyService.syncProxySendRPCRequest(msg); + } + } catch (UnsupportedEncodingException e) { + Log.e("SyncProxyTester", e.toString()); + } + }//if proxy is connected + else { + Log.i(LOG_TAG, "proxy is not connected"); + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add("proxy not connected"); + } + }); + } + } // if data != null + else { + Log.i(LOG_TAG, "data is null"); + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add("can't send to sync, data = null"); + } + }); + } + } // send to sync + } //if button = Send + + + } + + public byte[] assembleHeader(int payloadSize, byte[] payload) { + Log.i("syncp", "assembling header"); + _encodedSyncPDataHeader.setPayloadSize(payloadSize); + _encodedSyncPDataHeader.setPayload(payload); + _encodedSyncPDataHeader.setSigned(false); + _encodedSyncPDataHeader.setEncrypted(false); + _encodedSyncPDataHeader.setServiceType((byte) 7); + + + return _encodedSyncPDataHeader.assembleEncodedSyncPDataHeaderBytes(); + } + + + public String readFile() { + String jsonData = new String(); + try { + Scanner scanner = new Scanner(new FileReader(Environment.getExternalStorageDirectory().getPath() + "/policiesRequest.txt")); + + jsonData = scanner.nextLine(); + //Log.e(LOG_TAG, "first line: " + jsonData); + while (scanner.hasNextLine()) { + jsonData += scanner.nextLine().replaceAll(" ", ""); + //jsonData += scanner.nextLine(); + } + Log.i(LOG_TAG, "json from file: " + jsonData); + scanner.close(); + } catch (FileNotFoundException e) { + + Log.e(LOG_TAG, "FileNotFoundException " + e); + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add("connected to PC? file saved on sdcard?"); + } + }); + return null; + //_msgAdapter.logMessage("ensure the phone is not connected to PC. unmount sdcard"); + } catch (Exception e) { + //_msgAdapter.logMessage("Error reading policiesRequest.txt", Log.ERROR, e, true); + Log.e(LOG_TAG, "error " + e); + } + return jsonData; + } + + /*public void policies(final int timeout, String data) { + _postThreadActivity = new PostThreadActivity(url, data, timeout); + _postThreadActivity.execute(this); + }*/ + + public void policies(final int timeout) { + //String url = new String(); + String jsonData = new String(); + final String encodedSyncPDataReceived;// = new String(); + //try { + //add lock + /* + Scanner scanner = new Scanner(new FileReader("/sdcard/policiesRequest.txt")); + url = scanner.nextLine(); + + Log.i(LOG_TAG, "url from file: " + url); + while (scanner.hasNextLine()) { + //jsonData += scanner.nextLine().replaceAll(" ", ""); + jsonData += scanner.nextLine(); + } + Log.i(LOG_TAG, "jsondata from file: " + jsonData); + scanner.close(); + String data = jsonData; + //unlock + */ + + //encodedSyncPDataReceived = _appLinkService.getProxyInstance().sendEncodedSyncPDataToUrl(url, jsonData); + + //to Base64 encode + /*String data = "EncodeSyncP"; + * byte[] bytesToSend; + bytesToSend = data.getBytes("UTF-8"); + String encodedString = Base64.encodeToString(bytesToSend, Base64.DEFAULT); + Log.i(LOG_TAG, "encoded: " + encodedString +"test"); + String[] split = encodedString.split("\r\n"); + Log.i(LOG_TAG, "split: " + split[0]+"test");*/ + + + //"http://applinkdev1.cloudapp.net/api/Ford"; + + // final String data = "{\"data\":[\"HwcaAABt2lhQMjIwMEtHAAAABQAAAAUAHRHcxKMmVbBKTj6F3qEH4Wq0/zA=\"]}"; + + //final String data = "{\"data\":[\"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\"]}"; + + final String data = "{\"data\":[\"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\"]}"; + + //add thread + //_postThreadActivity = new PostThreadActivity(url, data, timeout); + //_postThreadActivity.execute(this); + + //start thread + new Thread(new Runnable() { + public void run() { + sendEncodedSyncPDataToUrl(url, data, timeout); + } + }).start(); + } + + public void logMessage(final Object m, Boolean addToUI) { + //Log.i(LOG_TAG, m.toString()); + addMessageToUI(m); + } + + public void logMessage(final Object m) { + //Log.i(LOG_TAG, m.toString()); + addMessageToUI(m); + } + + private void addMessageToUI(final Object m) { + //Log.i(LOG_TAG, "ui: " +m.toString()); + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add(m); + } + }); + } + + protected void onPostExecute(String encodedSyncPDataReceived, long roundtriptime) { + Log.i(LOG_TAG, "response: " + encodedSyncPDataReceived); + if (encodedSyncPDataReceived == "Error 500") { + logMessage("Error 500"); + } else logMessage("encodedSyncPDataReceived"); + //logMessage("" + encodedSyncPDataReceived, true); + logMessage("round trip time: " + roundtriptime + " ms"); + } + + protected void onPostExecute(String encodedSyncPDataReceived) { + Log.i(LOG_TAG, "response: " + encodedSyncPDataReceived); + //logMessage("" + encodedSyncPDataReceived, true); + if (encodedSyncPDataReceived == "Error 500") { + logMessage("Error 500", true); + } else { + logMessage("encodedSyncPDataReceived no time available", true); + } + //logMessage("round trip time: " + roundtriptime + " ms"); + } + + //private void sendEncodedSyncPDataToUrl(String urlString, Vector<String> encodedSyncPData, Integer timeout) { + + private void sendEncodedSyncPDataToUrl(String urlString, String encodedSyncPData, Integer timeout) { + try { + final int CONNECTION_TIMEOUT = timeout * 1000; //change to ms + Log.i(LOG_TAG, "sendEncodedSyncPDataToUrl timeout: " + CONNECTION_TIMEOUT); + Vector<String> encodedSyncPDataReceived = new Vector<String>(); + + // Form the JSON message to send to the cloud + //JSONArray jsonArrayOfSyncPPackets = new JSONArray(encodedSyncPData); + JSONObject jsonObjectToSendToServer = new JSONObject(); + //jsonObjectToSendToServer.put("data", jsonArrayOfSyncPPackets); + Log.i(LOG_TAG, "encodedSyncPData: " + encodedSyncPData); //same up to here + + //format packet received from sync? + /* + * jsonObjectToSendToServer.put("data", encodedSyncPData); + Log.i(LOG_TAG, "sending: "+ jsonObjectToSendToServer.toString()); //same up to here + byte[] bytesToSend = jsonObjectToSendToServer.toString().getBytes("UTF-8"); + */ + + //instead, when reading from file: + byte[] bytesToSend = encodedSyncPData.getBytes("UTF-8"); + + // Send the Bytes to the Cloud and get the Response + HttpParams httpParams = new BasicHttpParams(); + HttpConnectionParams.setConnectionTimeout(httpParams, CONNECTION_TIMEOUT); + HttpConnectionParams.setSoTimeout(httpParams, CONNECTION_TIMEOUT); + HttpClient client = new DefaultHttpClient(httpParams); + Log.i(LOG_TAG, "url: " + urlString); + HttpPost request = new HttpPost(urlString); + request.setHeader("Content-type", "application/json"); + request.setEntity(new ByteArrayEntity(bytesToSend)); + + long BeforeTime = System.currentTimeMillis(); + HttpResponse response = client.execute(request); + long AfterTime = System.currentTimeMillis(); + final long roundtriptime = AfterTime - BeforeTime; + Log.i(LOG_TAG, "roundtriptime: " + roundtriptime); + + String returnVal = new String(); + // If response is null, then return + if (response == null) { + Log.e(LOG_TAG, "Response from server returned null: "); + //Activity.runOnUiThread(Runnable) + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add("Response from server returned null"); + } + }); + return; + } else { //response not null + returnVal = EntityUtils.toString(response.getEntity(), "UTF-8"); + Log.i(LOG_TAG, "response: " + returnVal); + + if (response.getStatusLine().getStatusCode() == 200) { + + Log.i(LOG_TAG, "Status 200"); + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add("Status 200"); + } + }); + // Convert the response to JSON + //returnVal = EntityUtils.toString(response.getEntity(), "UTF-8"); + //Log.i(LOG_TAG, "response: "+returnVal); + JSONObject jsonResponse = new JSONObject(returnVal); + + + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add("round trip time: " + roundtriptime); + } + }); + //logMessage("" + encodedSyncPDataReceived, true); + //logMessage("round trip time: " + roundtriptime + " ms"); + + // Create and send the encodedSyncPData message back to SYNC + if (jsonResponse.get("data") instanceof JSONArray) { + JSONArray jsonArray = jsonResponse.getJSONArray("data"); + for (int i = 0; i < jsonArray.length(); i++) { + if (jsonArray.get(i) instanceof String) { + encodedSyncPDataReceived.add(jsonArray.getString(i)); + } + } + } else if (jsonResponse.get("data") instanceof String) { + encodedSyncPDataReceived.add(jsonResponse.getString("data")); + } else { + Log.e(LOG_TAG, "sendEncodedSyncPDataToUrl: Data in JSON Object neither an array nor a string."); + // Exit method + return; + } + + Log.i(LOG_TAG, "sending to sync..."); + //sendToSync(encodedSyncPDataReceived); + + + } else if (response.getStatusLine().getStatusCode() == 500) { + //returnVal = EntityUtils.toString(response.getEntity(), "UTF-8"); + returnVal = "Error 500"; + Log.i(LOG_TAG, "response: Error 500"); + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add("error: 500, round trip time: " + roundtriptime); + } + }); + //logMessage("response: Error 500"); + //logMessage("round trip time: " + roundtriptime + " ms"); + } else { + returnVal = "Unknown Error"; + Log.i(LOG_TAG, "response: Unknown Error"); + //logMessage("Unknown Error"); + //logMessage("round trip time: " + roundtriptime + " ms"); + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add("unknown 500, round trip time: " + roundtriptime); + } + }); + } + } + + // Send new encodedSyncPDataRequest to SYNC + //EncodedSyncPData encodedSyncPDataRequest = RPCRequestFactory.buildEncodedSyncPData(encodedSyncPDataReceived, getPoliciesReservedCorrelationID()); + //if (getIsConnected()) { + // sendRPCRequestPrivate(encodedSyncPDataRequest); + //} + //} catch (SyncException e) { + //DebugTool.logError("sendEncodedSyncPDataToUrl: Could not get data from JSONObject received.", e); + + } catch (JSONException e) { + Log.e(LOG_TAG, "sendEncodedSyncPDataToUrl: JSONException: " + e); + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add("unknown error, JSONException"); + } + }); + } catch (UnsupportedEncodingException e) { + Log.e(LOG_TAG, "sendEncodedSyncPDataToUrl: Could not encode string." + e); + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add("Could not encode string"); + } + }); + } catch (ClientProtocolException e) { //used to be (ProtocolException) + Log.e(LOG_TAG, "sendEncodedSyncPDataToUrl: Could not set request method to post." + e); + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add("ClientProtocolException"); + } + }); + } catch (MalformedURLException e) { + Log.e(LOG_TAG, "sendEncodedSyncPDataToUrl: URL Exception when sending EncodedSyncPData to an external server." + e); + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add("MalformedURLException"); + } + }); + } catch (IOException e) { + Log.e(LOG_TAG, "sendEncodedSyncPDataToUrl: IOException: " + e); + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add("IOException, can't reach url?"); + } + }); + } catch (Exception e) { + Log.e(LOG_TAG, "sendEncodedSyncPDataToUrl: Unexpected Exception: " + e); + runOnUiThread(new Runnable() { + public void run() { + _UImsgAdapter1.add("Unexpected Exception"); + } + }); + } + } + + /*public void sendToSync(Vector<String> encodedSyncPDataReceived) { + EncodedSyncPData encodedSyncPDataRequest = RPCRequestFactory.buildEncodedSyncPData(encodedSyncPDataReceived, 65535); + if(_syncProxy != null){ + //sendRPCRequestPrivate(encodedSyncPDataRequest); + try { + ProxyService.getInstance().getProxyInstance().sendRPCRequest(encodedSyncPDataRequest); + } catch (SyncException e) { + _msgAdapter.logMessage("Error sending message: " + e, Log.ERROR, e); + } + } + }*/ +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/policies/PolicyFilesManager.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/policies/PolicyFilesManager.java new file mode 100644 index 000000000..6617938d0 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/policies/PolicyFilesManager.java @@ -0,0 +1,99 @@ +package com.ford.syncV4.android.policies; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 2/26/14 + * Time: 9:59 AM + */ + +import android.os.Environment; +import android.util.Log; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.activity.SafeToast; +import com.ford.syncV4.android.adapters.LogAdapter; +import com.ford.syncV4.android.manager.AppPreferencesManager; +import com.ford.syncV4.android.utils.AppUtils; +import com.ford.syncV4.exception.SyncException; +import com.ford.syncV4.proxy.systemrequest.ISystemRequestProxy; + +import java.io.File; + +/** + * This class provide possibility to save Policy Table Snapshot file (which comes from SDL) + * and to send back Policy Table Update file + */ +public class PolicyFilesManager { + + /** + * Save Policy Table Snapshot data to file + * + * @param data Policy Table Snapshot data + */ + public static void savePolicyTableSnapshot(byte[] data) { + //final byte[] fileData = AppUtils.contentsOfResource(R.raw.policy_table_shanpshot); + String mTMPFilePath = Environment.getExternalStorageDirectory() + + "/policyTableSnapshot.json"; + + boolean result = AppUtils.saveDataToFile(data, mTMPFilePath); + if (result) { + SafeToast.showToastAnyThread("File '" + mTMPFilePath + "' successfully saved"); + } else { + SafeToast.showToastAnyThread("File '" + mTMPFilePath + "' could not be save"); + } + } + + /** + * Send Policy Table Update data to SDL + * + * @param proxy {@link com.ford.syncV4.proxy.systemrequest.ISystemRequestProxy} implementation + * @param logAdapter Log Adapter (TO BE REMOVED) + */ + public static void sendPolicyTableUpdate(ISystemRequestProxy proxy, LogAdapter logAdapter) { + String mPolicyTableUpdatePath = AppPreferencesManager.getPolicyTableUpdateFilePath(); + //Environment.getExternalStorageDirectory() + + // "/policyTableUpdate.json"; + + byte[] data = null; + if (mPolicyTableUpdatePath.equals("")) { + data = AppUtils.contentsOfResource(R.raw.policy_table_update); + } else { + File mPolicyUpdateFile = new File(mPolicyTableUpdatePath); + if (mPolicyUpdateFile.exists()) { + data = AppUtils.contentsOfResource(mPolicyUpdateFile); + } + } + + if (data == null) { + SafeToast.showToastAnyThread("Policy Snapshot could not be found"); + // TODO : Logging to be refactored + if (logAdapter != null) { + logAdapter.logMessage("Policy Snapshot could not be found", Log.ERROR, true); + } + return; + } + + SafeToast.showToastAnyThread("Policy Update is found"); + + // TODO : Logging to be refactored + if (logAdapter != null) { + logAdapter.logMessage("Policy Update is found", Log.DEBUG, true); + } + + try { + String mPolicyTableUpdateFileName = "PolicyTableUpdate"; + proxy.putPolicyTableUpdateFile(mPolicyTableUpdateFileName, data); + SafeToast.showToastAnyThread("Policy Update sent"); + if (logAdapter != null) { + logAdapter.logMessage("Policy Update sent", Log.DEBUG, true); + } + } catch (SyncException e) { + // TODO : Logging to be refactored + if (logAdapter != null) { + logAdapter.logMessage("Can't upload policy table update mPolicyUpdateFile:" + + e.getMessage(), Log.ERROR, true); + } + } + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/policies/UIMessageAdapter.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/policies/UIMessageAdapter.java new file mode 100644 index 000000000..6421be238 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/policies/UIMessageAdapter.java @@ -0,0 +1,40 @@ +package com.ford.syncV4.android.policies; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import android.content.Context; +import android.graphics.Color; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.ArrayAdapter; +import android.widget.TextView; + +import com.ford.syncV4.android.R; + +public class UIMessageAdapter extends ArrayAdapter<Object> { + private LayoutInflater vi; + + public UIMessageAdapter(Context context, int textViewResourceId) { + super(context, textViewResourceId); + this.vi = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE); + } + + public View getView(int position, View convertView, ViewGroup parent) { + ViewGroup rowView = (ViewGroup)convertView; + Object rpcObj = getItem(position); + rowView = (ViewGroup)vi.inflate(R.layout.policiesrow, null); + + if (rpcObj != null) { + TextView lblTop = (TextView) rowView.findViewById(R.id.toptext); + TextView lblBottom = (TextView) rowView.findViewById(R.id.bottomtext); + + if (rpcObj instanceof String) { + lblTop.setText((String)rpcObj); + } + + } + return rowView; + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/receivers/IBluetoothReceiver.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/receivers/IBluetoothReceiver.java new file mode 100644 index 000000000..be9ac389c --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/receivers/IBluetoothReceiver.java @@ -0,0 +1,13 @@ +package com.ford.syncV4.android.receivers; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 12/26/13 + * Time: 5:39 PM + */ +public interface IBluetoothReceiver { + void onBluetoothOn(); + void onBluetoothOff(); + void onBluetoothTurningOff(); +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/receivers/ISyncReceiver.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/receivers/ISyncReceiver.java new file mode 100644 index 000000000..9b059315e --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/receivers/ISyncReceiver.java @@ -0,0 +1,11 @@ +package com.ford.syncV4.android.receivers; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 1/28/14 + * Time: 2:01 PM + */ +public interface ISyncReceiver { + void onReceive(); +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/receivers/SyncReceiver.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/receivers/SyncReceiver.java new file mode 100644 index 000000000..779576254 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/receivers/SyncReceiver.java @@ -0,0 +1,91 @@ +package com.ford.syncV4.android.receivers; + +import android.bluetooth.BluetoothAdapter; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.util.Log; +import android.view.KeyEvent; + +import com.ford.syncV4.util.DebugTool; + +public class SyncReceiver extends BroadcastReceiver { + + private static final String TAG = "SyncProxyTester"; + + private IBluetoothReceiver mBluetoothReceiverCallback; + private ISyncReceiver mSyncReceiverCallback; + + public void setBluetoothReceiverCallback(IBluetoothReceiver bluetoothReceiverCallback) { + mBluetoothReceiverCallback = bluetoothReceiverCallback; + } + + public void setSyncReceiver(ISyncReceiver syncReceiverCallback) { + mSyncReceiverCallback = syncReceiverCallback; + } + + public void onReceive(Context context, Intent intent) { + DebugTool.logInfo("SyncReceiver.onReceive()"); + + String action = intent.getAction(); + + DebugTool.logInfo("Received Intent with action: " + action); + Log.i(TAG, "Received Intent with action: " + action); + + if (action == null) { + return; + } + + if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) { + int bluetoothState = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, -1); + switch (bluetoothState) { + case BluetoothAdapter.STATE_TURNING_OFF : + Log.i(TAG, "Bluetooth state STATE_TURNING_OFF"); + if (mBluetoothReceiverCallback != null) { + mBluetoothReceiverCallback.onBluetoothTurningOff(); + } + break; + case BluetoothAdapter.STATE_TURNING_ON : + Log.i(TAG, "Bluetooth state STATE_TURNING_ON"); + break; + case BluetoothAdapter.STATE_CONNECTED : + Log.i(TAG, "Bluetooth state STATE_CONNECTED"); + break; + case BluetoothAdapter.STATE_CONNECTING : + Log.i(TAG, "Bluetooth state STATE_CONNECTING"); + break; + case BluetoothAdapter.STATE_DISCONNECTED : + Log.i(TAG, "Bluetooth state STATE_DISCONNECTED"); + break; + case BluetoothAdapter.STATE_DISCONNECTING : + Log.i(TAG, "Bluetooth state STATE_DISCONNECTING"); + break; + case BluetoothAdapter.STATE_OFF : + Log.i(TAG, "Bluetooth state STATE_OFF"); + if (mBluetoothReceiverCallback != null) { + mBluetoothReceiverCallback.onBluetoothOff(); + } + break; + case BluetoothAdapter.STATE_ON : + Log.i(TAG, "Bluetooth state STATE_ON"); + if (mBluetoothReceiverCallback != null) { + mBluetoothReceiverCallback.onBluetoothOn(); + } + break; + } + } + + if (action.compareTo(Intent.ACTION_MEDIA_BUTTON) == 0) { + KeyEvent event = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT); + if (event != null && event.getKeyCode() == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) { + abortBroadcast(); + } + } + + if (action.equals(android.media.AudioManager.ACTION_AUDIO_BECOMING_NOISY)) { + if (mSyncReceiverCallback != null) { + mSyncReceiverCallback.onReceive(); + } + } + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/AppServiceConnectionProxyBase.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/AppServiceConnectionProxyBase.java new file mode 100644 index 000000000..c3d839bc2 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/AppServiceConnectionProxyBase.java @@ -0,0 +1,30 @@ +package com.ford.syncV4.android.service; + +import android.content.ComponentName; +import android.content.ServiceConnection; +import android.os.IBinder; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 11/19/13 + * Time: 11:53 AM + */ +public class AppServiceConnectionProxyBase implements ServiceConnection { + + private boolean mIsConnected = false; + + @Override + public void onServiceConnected(ComponentName name, IBinder service) { + mIsConnected = true; + } + + @Override + public void onServiceDisconnected(ComponentName name) { + mIsConnected = false; + } + + public boolean isConnected() { + return mIsConnected; + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/EncodedSyncPDataHeader.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/EncodedSyncPDataHeader.java new file mode 100644 index 000000000..b2d140034 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/EncodedSyncPDataHeader.java @@ -0,0 +1,395 @@ +package com.ford.syncV4.android.service; + +import com.ford.syncV4.util.BitConverter; + +public class EncodedSyncPDataHeader { + private byte protocolVersion; + private boolean responseRequired; + private boolean highBandwidth; + private boolean signed; + private boolean encrypted; + private boolean hasESN; + private byte serviceType; + private byte commandType; + private boolean CPUDestination; + private byte encryptionKeyIndex; + private int payloadSize; + private byte[] ESN; + private int moduleMessageID; + private int serverMessageID; + private byte messageStatus; + private byte[] IV; + private byte[] payload; + private byte[] signatureTag; + + public EncodedSyncPDataHeader() {} + + public static EncodedSyncPDataHeader parseEncodedSyncPDataHeader(byte[] header) { + EncodedSyncPDataHeader msg = new EncodedSyncPDataHeader(); + + int bandwidthStart; + + byte protocolVersion = (byte) (header[0] >>> 5); + msg.setProtocolVersion(protocolVersion); + + boolean responseRequired = 1 == ((header[0] & 0x10) >>> 4); + msg.setResponseRequired(responseRequired); + + boolean highBandwidth = 1 == ((header[0] & 0x08) >>> 3); + msg.setHighBandwidth(highBandwidth); + + boolean signed = 1 == ((header[0] & 0x04) >>> 2); + msg.setSigned(signed); + + boolean encrypted = 1 == ((header[0] & 0x02) >>> 1); + msg.setEncrypted(encrypted); + + boolean hasESN = 1 == (header[0] & 0x01); + msg.setHasESN(hasESN); + + byte serviceType = header[1]; + msg.setServiceType(serviceType); + + byte commandType = (byte) (header[2] >>> 4); + msg.setCommandType(commandType); + + boolean CPUDestination = 1 == ((header[2] & 0x08) >>> 3); + msg.setCPUDestination(CPUDestination); + + byte encryptionKeyIndex = (byte) (header[2] & 0x07); + msg.setEncryptionKeyIndex(encryptionKeyIndex); + + if (msg.getHighBandwidth()) { + bandwidthStart = 7; + int payloadSize = BitConverter.intFromByteArray(header, 3); + msg.setPayloadSize(payloadSize); + } else { + bandwidthStart = 5; + short payloadSize = BitConverter.shortFromByteArray(header, 3); + msg.setPayloadSize(payloadSize); + } + + byte[] ESN = new byte[8]; + int ESNLoc = 0; + for (int i = bandwidthStart; i < bandwidthStart + 8; i++) { + ESN[ESNLoc] = (byte) (header[i]); + ESNLoc++; + } + msg.setESN(ESN); + + if (msg.getHighBandwidth()) { + if (msg.getResponseRequired()) { + bandwidthStart += 17; + + int moduleMessageID = BitConverter.intFromByteArray(header, 15); + msg.setModuleMessageID(moduleMessageID); + + int serverMessageID = BitConverter.intFromByteArray(header, 19); + msg.setServerMessageID(serverMessageID); + + byte messageStatus = header[23]; + msg.setMessageStatus(messageStatus); + } else { + bandwidthStart += 8; + } + + byte[] IV = new byte[16]; + int IVLoc = 0; + for (int i = bandwidthStart; i < bandwidthStart + 16; i++) { + IV[IVLoc] = (byte) (header[i]); + IVLoc++; + } + msg.setIV(IV); + + bandwidthStart += 16; + + byte[] payload = new byte[msg.getPayloadSize()]; + int payloadLoc = 0; + for (int i = bandwidthStart; i < bandwidthStart + msg.getPayloadSize(); i++) { + payload[payloadLoc] = (byte) (header[i]); + payloadLoc++; + } + msg.setPayload(payload); + + bandwidthStart += msg.getPayloadSize(); + + byte[] signatureTag = new byte[16]; + int signatureTagLoc = 0; + for (int i = bandwidthStart; i < bandwidthStart + 16; i++) { + signatureTag[signatureTagLoc] = (byte) (header[i]); + signatureTagLoc++; + } + msg.setSignatureTag(signatureTag); + + } else { + bandwidthStart += 8; + + byte[] IV = new byte[8]; + int IVLoc = 0; + for (int i = bandwidthStart; i < bandwidthStart + 8; i++) { + IV[IVLoc] = (byte) (header[i]); + IVLoc++; + } + msg.setIV(IV); + + bandwidthStart += 8; + + byte[] payload = new byte[msg.getPayloadSize()]; + int payloadLoc = 0; + for (int i = bandwidthStart; i < bandwidthStart + msg.getPayloadSize(); i++) { + payload[payloadLoc] = (byte) (header[i]); + payloadLoc++; + } + msg.setPayload(payload); + + bandwidthStart += msg.getPayloadSize(); + + byte[] signatureTag = new byte[8]; + int signatureTagLoc = 0; + for (int i = bandwidthStart; i < bandwidthStart + 8; i++) { + signatureTag[signatureTagLoc] = (byte) (header[i]); + signatureTagLoc++; + } + msg.setSignatureTag(signatureTag); + } + + return msg; + } + + public byte[] assembleEncodedSyncPDataHeaderBytes() { + int EncodedSyncPDataHeader = 0; + //assign value on the right to EncodedSyncPHeader + EncodedSyncPDataHeader |= protocolVersion; + //shift 1 bit to the left + EncodedSyncPDataHeader <<= 1; + //convert boolean to int, then assign value + EncodedSyncPDataHeader |= (responseRequired ? 1 : 0); + EncodedSyncPDataHeader <<= 1; + EncodedSyncPDataHeader |= (highBandwidth ? 1 : 0); + EncodedSyncPDataHeader <<= 1; + EncodedSyncPDataHeader |= (signed ? 1 : 0); + EncodedSyncPDataHeader <<= 1; + EncodedSyncPDataHeader |= (encrypted ? 1 : 0); + EncodedSyncPDataHeader <<= 1; + EncodedSyncPDataHeader |= (hasESN ? 1 : 0); + EncodedSyncPDataHeader <<= 8; + EncodedSyncPDataHeader |= serviceType; + EncodedSyncPDataHeader <<= 4; + EncodedSyncPDataHeader |= commandType; + EncodedSyncPDataHeader <<= 1; + EncodedSyncPDataHeader |= (CPUDestination ? 1 : 0); + EncodedSyncPDataHeader <<= 3; + EncodedSyncPDataHeader |= encryptionKeyIndex; + + if (highBandwidth) { + if (responseRequired) { + int packetSize = + /*Standard Header Elements*/ 3 + + /*Payload Size*/ 4 + + /*ESN*/ 8 + + /*Module Message ID*/ 4 + + /*Server Message ID*/ 4 + + /*Message Status*/ 1 + + /*IV*/ 16 + + /*Payload*/ payloadSize + + /*Signature Tag*/ 16; + + byte[] ret = new byte[packetSize]; + + System.arraycopy(BitConverter.intToByteArray(EncodedSyncPDataHeader), 1, ret, 0, 3); + System.arraycopy(BitConverter.intToByteArray(payloadSize), 0, ret, 3, 4); + System.arraycopy(ESN, 0, ret, 7, 8); + System.arraycopy(BitConverter.intToByteArray(moduleMessageID), 0, ret, 15, 4); + System.arraycopy(BitConverter.intToByteArray(serverMessageID), 0, ret, 19, 4); + ret[23] = messageStatus; + System.arraycopy(IV, 0, ret, 24, 16); + System.arraycopy(payload, 0, ret, 40, payloadSize); + System.arraycopy(signatureTag, 0, ret, 40 + payloadSize, 16); + + return ret; + } else { + int packetSize = + /*Standard Header Elements*/ 3 + + /*Payload Size*/ 4 + + /*ESN*/ 8 + + /*IV*/ 16 + + /*Payload*/ payloadSize + + /*Signature Tag*/ 16; + + byte[] ret = new byte[packetSize]; + + System.arraycopy(BitConverter.intToByteArray(EncodedSyncPDataHeader), 1, ret, 0, 3); + System.arraycopy(BitConverter.intToByteArray(payloadSize), 0, ret, 3, 4); + System.arraycopy(ESN, 0, ret, 7, 8); + System.arraycopy(IV, 0, ret, 15, 16); + System.arraycopy(payload, 0, ret, 31, payloadSize); + System.arraycopy(signatureTag, 0, ret, 31 + payloadSize, 16); + + return ret; + } + } else { + int packetSize = + /*Standard Header Elements*/ 3 + + /*Payload Size*/ 2 + + /*ESN*/ 8 + + /*IV*/ 8 + + /*Payload*/ payloadSize + + /*Signature Tag*/ 8; + + byte[] ret = new byte[packetSize]; + + System.arraycopy(BitConverter.intToByteArray(EncodedSyncPDataHeader), 1, ret, 0, 3); + System.arraycopy(BitConverter.shortToByteArray((short) payloadSize), 0, ret, 3, 2); + System.arraycopy(ESN, 0, ret, 5, 8); + System.arraycopy(IV, 0, ret, 13, 8); + System.arraycopy(payload, 0, ret, 21, payloadSize); + System.arraycopy(signatureTag, 0, ret, 21 + payloadSize, 8); + + return ret; + } + } + + public byte getProtocolVersion() { + return protocolVersion; + } + + public void setProtocolVersion(byte protocolVersion) { + this.protocolVersion = protocolVersion; + } + + public boolean getResponseRequired() { + return responseRequired; + } + + public void setResponseRequired(boolean responseRequired) { + this.responseRequired = responseRequired; + } + + public boolean getHighBandwidth() { + return highBandwidth; + } + + public void setHighBandwidth(boolean highBandwidth) { + this.highBandwidth = highBandwidth; + } + + public boolean getSigned() { + return signed; + } + + public void setSigned(boolean signed) { + this.signed = signed; + } + + public boolean getEncrypted() { + return encrypted; + } + + public void setEncrypted(boolean encrypted) { + this.encrypted = encrypted; + } + + public boolean getHasESN() { + return hasESN; + } + + public void setHasESN(boolean hasESN) { + this.hasESN = hasESN; + } + + public byte getServiceType() { + return serviceType; + } + + public void setServiceType(byte serviceType) { + this.serviceType = serviceType; + } + + public byte getCommandType() { + return commandType; + } + + public void setCommandType(byte commandType) { + this.commandType = commandType; + } + + public boolean getCPUDestination() { + return CPUDestination; + } + + public void setCPUDestination(boolean CPUDestination) { + this.CPUDestination = CPUDestination; + } + + public byte getEncryptionKeyIndex() { + return encryptionKeyIndex; + } + + public void setEncryptionKeyIndex(byte encryptionKeyIndex) { + this.encryptionKeyIndex = encryptionKeyIndex; + } + + public int getPayloadSize() { + return payloadSize; + } + + public void setPayloadSize(int payloadSize) { + this.payloadSize = payloadSize; + } + + public byte[] getESN() { + return ESN; + } + + public void setESN(byte[] ESN) { + this.ESN = ESN; + } + + public int getModuleMessageID() { + return moduleMessageID; + } + + public void setModuleMessageID(int moduleMessageID) { + this.moduleMessageID = moduleMessageID; + } + + public int getServerMessageID() { + return serverMessageID; + } + + public void setServerMessageID(int serverMessageID) { + this.serverMessageID = serverMessageID; + } + + public byte getMessageStatus() { + return messageStatus; + } + + public void setMessageStatus(byte messageStatus) { + this.messageStatus = messageStatus; + } + + public byte[] getIV() { + return IV; + } + + public void setIV(byte[] IV) { + this.IV = IV; + } + + public byte[] getPayload() { + return payload; + } + + public void setPayload(byte[] payload) { + this.payload = payload; + } + + public byte[] getSignatureTag() { + return signatureTag; + } + + public void setSignatureTag(byte[] signatureTag) { + this.signatureTag = signatureTag; + } +} diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/ICloseSession.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/ICloseSession.java new file mode 100644 index 000000000..2eca05800 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/ICloseSession.java @@ -0,0 +1,11 @@ +package com.ford.syncV4.android.service; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 1/29/14 + * Time: 5:28 PM + */ +public interface ICloseSession { + void onCloseSessionComplete(); +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/IProxyServiceBinder.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/IProxyServiceBinder.java new file mode 100644 index 000000000..67fcbf659 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/IProxyServiceBinder.java @@ -0,0 +1,11 @@ +package com.ford.syncV4.android.service; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 1/29/14 + * Time: 5:02 PM + */ +public interface IProxyServiceBinder { + void onServiceBindComplete(); +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/IProxyServiceConnection.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/IProxyServiceConnection.java new file mode 100644 index 000000000..4812464d5 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/IProxyServiceConnection.java @@ -0,0 +1,12 @@ +package com.ford.syncV4.android.service; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 11/19/13 + * Time: 11:56 AM + */ +public interface IProxyServiceConnection { + void onProxyServiceConnected(ProxyServiceBinder service); + void onProxyServiceDisconnected(); +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/IProxyServiceEvent.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/IProxyServiceEvent.java new file mode 100644 index 000000000..94b857591 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/IProxyServiceEvent.java @@ -0,0 +1,56 @@ +package com.ford.syncV4.android.service; + +import com.ford.syncV4.protocol.enums.ServiceType; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 12/17/13 + * Time: 3:46 PM + */ + +/** + * This interface provide callbacks to the Service lifecycle events (Start, Stop) + */ +public interface IProxyServiceEvent { + + /** + * Dispatch when receive RPC service end message + */ + public void onDisposeComplete(); + + /** + * Dispatch when receive disposing of the RPC service gas an error + */ + public void onDisposeError(); + + /** + * Dispatch when receive service end message + * + * @param serviceType a type of the service + */ + public void onServiceEnd(ServiceType serviceType); + + /** + * Dispatch when receive service start message (in case of RPC Service) + * + * @param serviceType a type of the service + * @param sessionId Id of the session + */ + public void onServiceStart(ServiceType serviceType, byte sessionId); + + /** + * Dispatch when receive Ack message + * + * @param frameReceived frame received number + * @param serviceType a type of the service + */ + public void onAckReceived(int frameReceived, ServiceType serviceType); + + /** + * Dispatch when Service Nack received + * + * @param serviceType a type of the service + */ + public void onStartServiceNackReceived(ServiceType serviceType); +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/ProxyService.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/ProxyService.java new file mode 100644 index 000000000..34e55bf83 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/ProxyService.java @@ -0,0 +1,2220 @@ +package com.ford.syncV4.android.service; + +import android.app.Service; +import android.bluetooth.BluetoothAdapter; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.SharedPreferences; +import android.media.MediaPlayer; +import android.net.ConnectivityManager; +import android.net.NetworkInfo; +import android.os.Environment; +import android.os.IBinder; +import android.util.Log; +import android.util.Pair; +import android.util.SparseArray; + +import com.ford.syncV4.android.MainApp; +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.activity.SyncProxyTester; +import com.ford.syncV4.android.adapters.LogAdapter; +import com.ford.syncV4.android.constants.Const; +import com.ford.syncV4.android.constants.FlavorConst; +import com.ford.syncV4.android.listener.ConnectionListenersManager; +import com.ford.syncV4.android.manager.AppPreferencesManager; +import com.ford.syncV4.android.manager.LastUsedHashIdsManager; +import com.ford.syncV4.android.manager.PutFileTransferManager; +import com.ford.syncV4.android.manager.RPCRequestsResumableManager; +import com.ford.syncV4.android.module.ModuleTest; +import com.ford.syncV4.android.policies.PoliciesTest; +import com.ford.syncV4.android.policies.PoliciesTesterActivity; +import com.ford.syncV4.android.policies.PolicyFilesManager; +import com.ford.syncV4.android.receivers.SyncReceiver; +import com.ford.syncV4.android.service.proxy.OnSystemRequestHandler; +import com.ford.syncV4.android.utils.AppUtils; +import com.ford.syncV4.exception.SyncException; +import com.ford.syncV4.exception.SyncExceptionCause; +import com.ford.syncV4.marshal.IJsonRPCMarshaller; +import com.ford.syncV4.protocol.enums.ServiceType; +import com.ford.syncV4.proxy.RPCRequest; +import com.ford.syncV4.proxy.RPCRequestFactory; +import com.ford.syncV4.proxy.SyncProxyALM; +import com.ford.syncV4.proxy.constants.Names; +import com.ford.syncV4.proxy.interfaces.IProxyListenerALMTesting; +import com.ford.syncV4.proxy.rpc.AddCommand; +import com.ford.syncV4.proxy.rpc.AddCommandResponse; +import com.ford.syncV4.proxy.rpc.AddSubMenu; +import com.ford.syncV4.proxy.rpc.AddSubMenuResponse; +import com.ford.syncV4.proxy.rpc.AlertManeuverResponse; +import com.ford.syncV4.proxy.rpc.AlertResponse; +import com.ford.syncV4.proxy.rpc.ChangeRegistrationResponse; +import com.ford.syncV4.proxy.rpc.Choice; +import com.ford.syncV4.proxy.rpc.CreateInteractionChoiceSet; +import com.ford.syncV4.proxy.rpc.CreateInteractionChoiceSetResponse; +import com.ford.syncV4.proxy.rpc.DeleteCommandResponse; +import com.ford.syncV4.proxy.rpc.DeleteFileResponse; +import com.ford.syncV4.proxy.rpc.DeleteInteractionChoiceSetResponse; +import com.ford.syncV4.proxy.rpc.DeleteSubMenuResponse; +import com.ford.syncV4.proxy.rpc.EncodedSyncPDataResponse; +import com.ford.syncV4.proxy.rpc.EndAudioPassThruResponse; +import com.ford.syncV4.proxy.rpc.GenericResponse; +import com.ford.syncV4.proxy.rpc.GetDTCsResponse; +import com.ford.syncV4.proxy.rpc.GetVehicleDataResponse; +import com.ford.syncV4.proxy.rpc.ListFilesResponse; +import com.ford.syncV4.proxy.rpc.OnAudioPassThru; +import com.ford.syncV4.proxy.rpc.OnButtonEvent; +import com.ford.syncV4.proxy.rpc.OnButtonPress; +import com.ford.syncV4.proxy.rpc.OnCommand; +import com.ford.syncV4.proxy.rpc.OnDriverDistraction; +import com.ford.syncV4.proxy.rpc.OnEncodedSyncPData; +import com.ford.syncV4.proxy.rpc.OnHMIStatus; +import com.ford.syncV4.proxy.rpc.OnHashChange; +import com.ford.syncV4.proxy.rpc.OnKeyboardInput; +import com.ford.syncV4.proxy.rpc.OnLanguageChange; +import com.ford.syncV4.proxy.rpc.OnPermissionsChange; +import com.ford.syncV4.proxy.rpc.OnSyncPData; +import com.ford.syncV4.proxy.rpc.OnSystemRequest; +import com.ford.syncV4.proxy.rpc.OnTBTClientState; +import com.ford.syncV4.proxy.rpc.OnTouchEvent; +import com.ford.syncV4.proxy.rpc.OnVehicleData; +import com.ford.syncV4.proxy.rpc.PerformAudioPassThruResponse; +import com.ford.syncV4.proxy.rpc.PerformInteractionResponse; +import com.ford.syncV4.proxy.rpc.PutFile; +import com.ford.syncV4.proxy.rpc.PutFileResponse; +import com.ford.syncV4.proxy.rpc.ReadDIDResponse; +import com.ford.syncV4.proxy.rpc.RegisterAppInterface; +import com.ford.syncV4.proxy.rpc.RegisterAppInterfaceResponse; +import com.ford.syncV4.proxy.rpc.ResetGlobalPropertiesResponse; +import com.ford.syncV4.proxy.rpc.ScrollableMessageResponse; +import com.ford.syncV4.proxy.rpc.SetAppIcon; +import com.ford.syncV4.proxy.rpc.SetAppIconResponse; +import com.ford.syncV4.proxy.rpc.SetDisplayLayoutResponse; +import com.ford.syncV4.proxy.rpc.SetGlobalProperties; +import com.ford.syncV4.proxy.rpc.SetGlobalPropertiesResponse; +import com.ford.syncV4.proxy.rpc.SetMediaClockTimerResponse; +import com.ford.syncV4.proxy.rpc.Show; +import com.ford.syncV4.proxy.rpc.ShowConstantTBTResponse; +import com.ford.syncV4.proxy.rpc.ShowResponse; +import com.ford.syncV4.proxy.rpc.SliderResponse; +import com.ford.syncV4.proxy.rpc.SpeakResponse; +import com.ford.syncV4.proxy.rpc.SubscribeButton; +import com.ford.syncV4.proxy.rpc.SubscribeButtonResponse; +import com.ford.syncV4.proxy.rpc.SubscribeVehicleData; +import com.ford.syncV4.proxy.rpc.SubscribeVehicleDataResponse; +import com.ford.syncV4.proxy.rpc.SyncMsgVersion; +import com.ford.syncV4.proxy.rpc.SyncPDataResponse; +import com.ford.syncV4.proxy.rpc.SystemRequestResponse; +import com.ford.syncV4.proxy.rpc.UnregisterAppInterfaceResponse; +import com.ford.syncV4.proxy.rpc.UnsubscribeButtonResponse; +import com.ford.syncV4.proxy.rpc.UnsubscribeVehicleData; +import com.ford.syncV4.proxy.rpc.UnsubscribeVehicleDataResponse; +import com.ford.syncV4.proxy.rpc.UpdateTurnListResponse; +import com.ford.syncV4.proxy.rpc.enums.AppHMIType; +import com.ford.syncV4.proxy.rpc.enums.AppInterfaceUnregisteredReason; +import com.ford.syncV4.proxy.rpc.enums.ButtonName; +import com.ford.syncV4.proxy.rpc.enums.FileType; +import com.ford.syncV4.proxy.rpc.enums.HMILevel; +import com.ford.syncV4.proxy.rpc.enums.Language; +import com.ford.syncV4.proxy.rpc.enums.Result; +import com.ford.syncV4.session.Session; +import com.ford.syncV4.transport.BTTransportConfig; +import com.ford.syncV4.transport.BaseTransportConfig; +import com.ford.syncV4.transport.TCPTransportConfig; +import com.ford.syncV4.transport.usb.USBTransportConfig; +import com.ford.syncV4.util.Base64; +import com.ford.syncV4.util.TestConfig; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileWriter; +import java.io.IOException; +import java.io.OutputStream; +import java.util.Arrays; +import java.util.Vector; + +public class ProxyService extends Service implements IProxyListenerALMTesting { + + static final String TAG = "SyncProxyTester"; + + private static final String APPID_BT = FlavorConst.APPID_BT; + private static final String APPID_TCP = FlavorConst.APPID_TCP; + private static final String APPID_USB = FlavorConst.APPID_USB; + public static final int HEARTBEAT_INTERVAL = 5000; + public static final int HEARTBEAT_INTERVAL_MAX = Integer.MAX_VALUE; + private Integer autoIncCorrId = 1; + + private static final String ICON_SYNC_FILENAME = "icon.png"; + private static final String ICON_FILENAME_SUFFIX = ".png"; + + private static final int XML_TEST_COMMAND = 100; + private static final int POLICIES_TEST_COMMAND = 101; + + private SyncProxyALM mSyncProxy; + private LogAdapter mLogAdapter; + private ModuleTest mTesterMain; + private MediaPlayer mEmbeddedAudioPlayer; + private Boolean playingAudio = false; + protected SyncReceiver mediaButtonReceiver; + + private boolean firstHMIStatusChange = true; + private HMILevel prevHMILevel = HMILevel.HMI_NONE; + + private boolean mWaitingForResponse = false; + private IProxyServiceEvent mProxyServiceEvent; + private ICloseSession mCloseSessionCallback; + + private int mAwaitingInitIconResponseCorrelationID; + private PutFileTransferManager mPutFileTransferManager; + private ConnectionListenersManager mConnectionListenersManager; + private final IBinder mBinder = new ProxyServiceBinder(this); + // This manager provide functionality to process RPC requests which are involved in app resumption + private RPCRequestsResumableManager mRpcRequestsResumableManager = + new RPCRequestsResumableManager(); + // This Config object stores all the necessary data for SDK testing + private TestConfig mTestConfig = new TestConfig(); + + @Override + public void onCreate() { + super.onCreate(); + + createInfoMessageForAdapter("ProxyService.onCreate()"); + Log.i(TAG, ProxyService.class.getSimpleName() + " OnCreate, mSyncProxy:" + mSyncProxy); + + // Init Listener managers (ConnectionListenersManager, etc ...) + mConnectionListenersManager = new ConnectionListenersManager(); + + IntentFilter mediaIntentFilter = new IntentFilter(); + mediaIntentFilter.addAction(Intent.ACTION_MEDIA_BUTTON); + + mediaButtonReceiver = new SyncReceiver(); + registerReceiver(mediaButtonReceiver, mediaIntentFilter); + + //startProxyIfNetworkConnected(); + + mPutFileTransferManager = new PutFileTransferManager(); + + mRpcRequestsResumableManager.setCallback(new RPCRequestsResumableManager.RPCRequestsResumableManagerCallback() { + @Override + public void onSendRequest(RPCRequest request) { + syncProxySendRPCRequest(request); + } + }); + + MainApp.getInstance().getLastUsedHashIdsManager().init(); + } + + public void showLockMain() { + if (SyncProxyTester.getInstance() == null) { + Intent i = new Intent(this, SyncProxyTester.class); + i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + startActivity(i); + + // quite a few things downstream depend on the main activity and its + // fields being alive, so wait for a while here + int numTries = 9; + while ((SyncProxyTester.getInstance() == null) && (numTries-- >= 0)) { + try { + Thread.sleep(50); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + Log.d(TAG, "created " + SyncProxyTester.getInstance()); + } + } + + @Override + public int onStartCommand(Intent intent, int flags, int startId) { + Log.i(TAG, ProxyService.class.getSimpleName() + " OnStartCommand"); + createInfoMessageForAdapter("ProxyService.onStartCommand()"); + return START_STICKY; + } + + /** + * Function checks if WiFi enabled. + * Manifest permission is required: + * <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/> + * + * @return true if enabled + */ + private boolean hasWiFiConnection() { + boolean result = false; + + ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); + if (cm != null) { + NetworkInfo[] netInfo = cm.getAllNetworkInfo(); + if (netInfo != null) { + for (NetworkInfo ni : netInfo) { + if (ni.getTypeName().equalsIgnoreCase("WIFI")) { + Log.d(TAG, ni.getTypeName()); + if (ni.isConnected()) { + Log.d(TAG, + "ProxyService().hasWiFiConnection(): wifi conncetion found"); + result = true; + } + } + } + } + } + return result; + } + + public void startProxyIfNetworkConnected() { + SharedPreferences prefs = getSharedPreferences(Const.PREFS_NAME, MODE_PRIVATE); + int transportType = prefs.getInt( + Const.Transport.PREFS_KEY_TRANSPORT_TYPE, + Const.Transport.PREFS_DEFAULT_TRANSPORT_TYPE); + Log.i(TAG, "ProxyService. Start Proxy If Network Connected"); + boolean doStartProxy = false; + if (transportType == Const.Transport.KEY_BLUETOOTH) { + Log.i(TAG, "ProxyService. Transport = Bluetooth."); + BluetoothAdapter mBtAdapter = BluetoothAdapter.getDefaultAdapter(); + if (mBtAdapter != null) { + if (mBtAdapter.isEnabled()) { + doStartProxy = true; + } + } + } else { + Log.i(TAG, "ProxyService. Transport = Default."); + //TODO: This code is commented out for simulator purposes + /* + Log.d(TAG, "ProxyService. onStartCommand(). Transport = WiFi."); + if (hasWiFiConnection() == true) { + Log.d(TAG, "ProxyService. onStartCommand(). WiFi enabled."); + startProxy(); + } else { + Log.w(TAG, + "ProxyService. onStartCommand(). WiFi is not enabled."); + } + */ + doStartProxy = true; + } + if (doStartProxy) { + + // Prepare all necessary data that need to be use in the Tests + prepareTestConfig(); + + boolean result = startProxy(); + Log.i(TAG, ProxyService.class.getSimpleName() + " Proxy complete result:" + result); + /*if (result) { + try { + mSyncProxy.openSession(); + } catch (SyncException e) { + Log.e(TAG, "ProxyService - OpenSession", e); + } + }*/ + } + } + + /** + * Prepare all necessary parameters to be passed to Sync proxy + */ + private void prepareTestConfig() { + mTestConfig.setUseHashId(AppPreferencesManager.getUseHashId()); + mTestConfig.setCustomHashId(AppPreferencesManager.getCustomHashId()); + mTestConfig.setUseCustomHashId(AppPreferencesManager.getUseCustomHashId()); + } + + private boolean startProxy() { + SyncProxyALM.enableDebugTool(); + + createInfoMessageForAdapter("ProxyService.startProxy()"); + Log.i(TAG, ProxyService.class.getSimpleName() + " Start Proxy"); + + if (mSyncProxy == null) { + try { + SharedPreferences settings = getSharedPreferences(Const.PREFS_NAME, 0); + boolean isMediaApp = settings.getBoolean( + Const.PREFS_KEY_ISMEDIAAPP, + Const.PREFS_DEFAULT_ISMEDIAAPP); + boolean isNaviApp = settings.getBoolean( + Const.PREFS_KEY_ISNAVIAPP, + Const.PREFS_DEFAULT_ISNAVIAPP); + int versionNumber = getCurrentProtocolVersion(); + String appName = settings.getString(Const.PREFS_KEY_APPNAME, + Const.PREFS_DEFAULT_APPNAME); + Language lang = Language.valueOf(settings.getString( + Const.PREFS_KEY_LANG, Const.PREFS_DEFAULT_LANG)); + Language hmiLang = Language.valueOf(settings.getString( + Const.PREFS_KEY_HMILANG, Const.PREFS_DEFAULT_HMILANG)); + Log.i(TAG, "Using protocol version " + versionNumber); + int transportType = settings.getInt( + Const.Transport.PREFS_KEY_TRANSPORT_TYPE, + Const.Transport.PREFS_DEFAULT_TRANSPORT_TYPE); + String ipAddress = settings.getString( + Const.Transport.PREFS_KEY_TRANSPORT_IP, + Const.Transport.PREFS_DEFAULT_TRANSPORT_IP); + int tcpPort = settings.getInt( + Const.Transport.PREFS_KEY_TRANSPORT_PORT, + Const.Transport.PREFS_DEFAULT_TRANSPORT_PORT); + boolean mIsNSD = settings.getBoolean(Const.Transport.PREFS_KEY_IS_NSD, false); + + SyncMsgVersion syncMsgVersion = new SyncMsgVersion(); + syncMsgVersion.setMajorVersion(2); + syncMsgVersion.setMinorVersion(2); + Vector<AppHMIType> appHMITypes = createAppTypeVector(isNaviApp); + String appID = null; + BaseTransportConfig config = null; + switch (transportType) { + case Const.Transport.KEY_BLUETOOTH: + config = new BTTransportConfig(); + appID = APPID_BT; + break; + case Const.Transport.KEY_TCP: + config = new TCPTransportConfig(tcpPort, ipAddress); + ((TCPTransportConfig) config).setIsNSD(mIsNSD); + ((TCPTransportConfig) config).setApplicationContext(this); + appID = APPID_TCP; + break; + case Const.Transport.KEY_USB: + config = new USBTransportConfig(getApplicationContext()); + appID = APPID_USB; + break; + } + + mSyncProxy = new SyncProxyALM(this, + /*sync proxy configuration resources*/null, + /*enable advanced lifecycle management true,*/ + appName, + /*ngn media app*/null, + /*vr synonyms*/null, + /*is media app*/isMediaApp, appHMITypes, + syncMsgVersion, + /*language desired*/lang, + /*HMI Display Language Desired*/hmiLang, + appID, + /*autoActivateID*/null, + /*callbackToUIThre1ad*/ false, + /*preRegister*/ false, + versionNumber, + config, mTestConfig); + } catch (SyncException e) { + Log.e(TAG, e.toString()); + //error creating proxy, returned proxy = null + if (mSyncProxy == null) { + stopServiceBySelf(); + return false; + } + } + } + + OnSystemRequestHandler mOnSystemRequestHandler = new OnSystemRequestHandler(mLogAdapter); + + mSyncProxy.setOnSystemRequestHandler(mOnSystemRequestHandler); + + createInfoMessageForAdapter("ProxyService.startProxy() complete"); + Log.i(TAG, ProxyService.class.getSimpleName() + " Start Proxy complete:" + mSyncProxy); + + return mSyncProxy != null && mSyncProxy.getIsConnected(); + } + + private Vector<AppHMIType> createAppTypeVector(boolean naviApp) { + if (naviApp) { + Vector<AppHMIType> vector = new Vector<AppHMIType>(); + vector.add(AppHMIType.NAVIGATION); + return vector; + } + return null; + } + + private int getCurrentProtocolVersion() { + return Const.PROTOCOL_VERSION_2; + } + + private boolean getAutoSetAppIconFlag() { + return getSharedPreferences(Const.PREFS_NAME, 0).getBoolean( + Const.PREFS_KEY_AUTOSETAPPICON, + Const.PREFS_DEFAULT_AUTOSETAPPICON); + } + + @Override + public void onDestroy() { + createInfoMessageForAdapter("ProxyService.onDestroy()"); + + // In case service is destroying by System + if (mProxyServiceEvent == null) { + // TODO : Reconsider this case, for instance if we just close Session + //disposeSyncProxy(); + } + setProxyServiceEvent(null); + if (mEmbeddedAudioPlayer != null) { + mEmbeddedAudioPlayer.release(); + } + unregisterReceiver(mediaButtonReceiver); + super.onDestroy(); + } + + public void sendPolicyTableUpdate() { + PolicyFilesManager.sendPolicyTableUpdate(mSyncProxy, mLogAdapter); + } + + public void setCloseSessionCallback(ICloseSession closeSessionCallback) { + mCloseSessionCallback = closeSessionCallback; + } + + public void setProxyServiceEvent(IProxyServiceEvent proxyServiceEvent) { + mProxyServiceEvent = proxyServiceEvent; + } + + public void destroyService() { + disposeSyncProxy(); + } + + private void disposeSyncProxy() { + createInfoMessageForAdapter("ProxyService.disposeSyncProxy()"); + + MainApp.getInstance().getLastUsedHashIdsManager().save(); + + if (mSyncProxy != null) { + try { + mSyncProxy.dispose(); + } catch (SyncException e) { + Log.e(TAG, e.toString()); + if (mProxyServiceEvent != null) { + mProxyServiceEvent.onDisposeError(); + } + } + mSyncProxy = null; + } + } + + public int getServicesNumber() { + return mSyncProxy.getServicesNumber(); + } + + public boolean hasServiceInServicesPool(ServiceType serviceType) { + return mSyncProxy != null && mSyncProxy.hasServiceInServicesPool(serviceType); + } + + private void initialize() { + Log.d(TAG, "Initialize predefined view"); + playingAudio = true; + playAnnoyingRepetitiveAudio(); + + try { + show("Sync Proxy", "Tester"); + } catch (SyncException e) { + createErrorMessageForAdapter("Error sending show", e); + } + + commandSubscribeButtonPredefined(ButtonName.OK, getNextCorrelationID()); + commandSubscribeButtonPredefined(ButtonName.SEEKLEFT, getNextCorrelationID()); + commandSubscribeButtonPredefined(ButtonName.SEEKRIGHT, getNextCorrelationID()); + commandSubscribeButtonPredefined(ButtonName.TUNEUP, getNextCorrelationID()); + commandSubscribeButtonPredefined(ButtonName.TUNEDOWN, getNextCorrelationID()); + + Vector<ButtonName> buttons = new Vector<ButtonName>(Arrays.asList(new ButtonName[]{ + ButtonName.OK, ButtonName.SEEKLEFT, ButtonName.SEEKRIGHT, ButtonName.TUNEUP, + ButtonName.TUNEDOWN})); + SyncProxyTester.getInstance().buttonsSubscribed(buttons); + + commandAddCommandPredefined(XML_TEST_COMMAND, new Vector<String>(Arrays.asList(new String[]{"XML Test", "XML"})), "XML Test"); + commandAddCommandPredefined(POLICIES_TEST_COMMAND, new Vector<String>(Arrays.asList(new String[]{"Policies Test", "Policies"})), "Policies Test"); + } + + private void sendPutFileForAppIcon() { + Log.d(TAG, "PutFileForAppIcon"); + mAwaitingInitIconResponseCorrelationID = getNextCorrelationID(); + commandPutFile(FileType.GRAPHIC_PNG, ICON_SYNC_FILENAME, AppUtils.contentsOfResource(R.raw.fiesta), + mAwaitingInitIconResponseCorrelationID, true); + } + + private void show(String mainField1, String mainField2) throws SyncException { + Show msg = new Show(); + msg.setCorrelationID(getNextCorrelationID()); + msg.setMainField1(mainField1); + msg.setMainField2(mainField2); + if (mLogAdapter != null) { + mLogAdapter.logMessage(msg, true); + } + mSyncProxy.sendRPCRequest(msg); + } + + public void playPauseAnnoyingRepetitiveAudio() { + if (mEmbeddedAudioPlayer != null && mEmbeddedAudioPlayer.isPlaying()) { + playingAudio = false; + pauseAnnoyingRepetitiveAudio(); + } else { + playingAudio = true; + playAnnoyingRepetitiveAudio(); + } + } + + private void playAnnoyingRepetitiveAudio() { + if (mEmbeddedAudioPlayer == null) { + mEmbeddedAudioPlayer = MediaPlayer.create(this, R.raw.arco); + mEmbeddedAudioPlayer.setLooping(true); + } + mEmbeddedAudioPlayer.start(); + + createDebugMessageForAdapter("Playing audio"); + } + + public void pauseAnnoyingRepetitiveAudio() { + if (mEmbeddedAudioPlayer != null && mEmbeddedAudioPlayer.isPlaying()) { + mEmbeddedAudioPlayer.pause(); + + createDebugMessageForAdapter("Paused Audio"); + } + } + + public boolean isSyncProxyNotNull() { + return mSyncProxy != null; + } + + public boolean isSyncProxyConnected() { + return mSyncProxy != null && mSyncProxy.getIsConnected(); + } + + public boolean isSyncProxyConnectionNotNull() { + return mSyncProxy != null && mSyncProxy.getSyncConnection() != null; + } + + public void startModuleTest() { + mTesterMain = new ModuleTest(this, mLogAdapter); + } + + public void waiting(boolean waiting) { + mWaitingForResponse = waiting; + } + + public void setLogAdapter(LogAdapter logAdapter) { + // TODO : Reconsider. Implement log message dispatching instead + mLogAdapter = logAdapter; + } + + protected int getNextCorrelationID() { + return autoIncCorrId++; + } + + @Override + public void onOnHMIStatus(OnHMIStatus notification) { + createDebugMessageForAdapter(notification); + //createDebugMessageForAdapter("HMI level:" + notification.getHmiLevel()); + + switch (notification.getSystemContext()) { + case SYSCTXT_MAIN: + break; + case SYSCTXT_VRSESSION: + break; + case SYSCTXT_MENU: + break; + default: + return; + } + + switch (notification.getAudioStreamingState()) { + case AUDIBLE: + if (playingAudio) playAnnoyingRepetitiveAudio(); + break; + case NOT_AUDIBLE: + pauseAnnoyingRepetitiveAudio(); + break; + default: + return; + } + + final HMILevel curHMILevel = notification.getHmiLevel(); + final Boolean appInterfaceRegistered = mSyncProxy.getAppInterfaceRegistered(); + + if ((HMILevel.HMI_NONE == curHMILevel) && appInterfaceRegistered && firstHMIStatusChange) { + if (!isModuleTesting()) { + // Process an init state of the predefined requests here, assume that if + // hashId is not null means this is resumption + if (mSyncProxy.getHashId() == null) { + sendPutFileForAppIcon(); + } + } + } + + if (prevHMILevel != curHMILevel) { + boolean hmiChange = false; + boolean hmiFull = false; + switch (curHMILevel) { + case HMI_FULL: + hmiFull = true; + hmiChange = true; + break; + case HMI_LIMITED: + hmiChange = true; + break; + case HMI_BACKGROUND: + hmiChange = true; + break; + case HMI_NONE: + break; + default: + return; + } + prevHMILevel = curHMILevel; + + if (appInterfaceRegistered) { + if (hmiFull) { + if (firstHMIStatusChange) { + showLockMain(); + mTesterMain = new ModuleTest(this, mLogAdapter); + //mTesterMain = ModuleTest.getModuleTestInstance(); + + // Process an init state of the predefined requests here, assume that if + // hashId is not null means this is resumption + if (mSyncProxy.getHashId() == null) { + initialize(); + } else { + setAppIcon(); + } + } else { + try { + if (mTesterMain != null && !mWaitingForResponse && mTesterMain.getThreadContext() != null) { + show("Sync Proxy", "Tester Ready"); + } + } catch (SyncException e) { + if (mLogAdapter == null) + Log.w(TAG, "LogAdapter is null"); + if (mLogAdapter != null) + mLogAdapter.logMessage("Error sending show", Log.ERROR, e, true); + else Log.e(TAG, "Error sending show", e); + } + } + } + + if (hmiChange && firstHMIStatusChange) { + firstHMIStatusChange = false; + + // Process an init state of the predefined requests here, assume that if + // hashId is not null means this is resumption + if (mSyncProxy.getHashId() == null) { + try { + // upload turn icons + sendIconFromResource(R.drawable.turn_left); + sendIconFromResource(R.drawable.turn_right); + sendIconFromResource(R.drawable.turn_forward); + sendIconFromResource(R.drawable.action); + } catch (SyncException e) { + Log.w(TAG, "Failed to put images", e); + } + } + } + } + } + } + + @Override + public void onHashChange(OnHashChange onHashChange) { + createDebugMessageForAdapter(onHashChange); + + LastUsedHashIdsManager lastUsedHashIdsManager = MainApp.getInstance().getLastUsedHashIdsManager(); + lastUsedHashIdsManager.addNewId(onHashChange.getHashID()); + } + + /** + * Checks and returns if the module testing is in progress. + * + * @return true if the module testing is in progress + */ + private boolean isModuleTesting() { + return mWaitingForResponse && mTesterMain.getThreadContext() != null; + } + + private void sendIconFromResource(int resource) throws SyncException { + commandPutFile(FileType.GRAPHIC_PNG, + getResources().getResourceEntryName(resource) + ICON_FILENAME_SUFFIX, + AppUtils.contentsOfResource(resource), getNextCorrelationID(), true); + } + + @Override + public void onOnCommand(OnCommand notification) { + createDebugMessageForAdapter(notification); + switch (notification.getCmdID()) { + case XML_TEST_COMMAND: + mTesterMain.restart(null); + break; + case POLICIES_TEST_COMMAND: + PoliciesTest.runPoliciesTest(this, mLogAdapter); + break; + default: + break; + } + } + + @Override + public void onProxyClosed(final String info, Exception e) { + if (e != null) { + createErrorMessageForAdapter("OnProxyClosed:" + info + ", msg:" + e.getMessage()); + } else { + createErrorMessageForAdapter("OnProxyClosed:" + info); + } + boolean wasConnected = !firstHMIStatusChange; + firstHMIStatusChange = true; + prevHMILevel = HMILevel.HMI_NONE; + + if (wasConnected) { + mConnectionListenersManager.dispatch(); + } + + if (!isModuleTesting()) { + if (e == null) { + return; + } + if (e instanceof SyncException) { + final SyncExceptionCause cause = ((SyncException) e).getSyncExceptionCause(); + if ((cause != SyncExceptionCause.SYNC_PROXY_CYCLED) && + (cause != SyncExceptionCause.BLUETOOTH_DISABLED) && + (cause != SyncExceptionCause.SYNC_REGISTRATION_ERROR)) { + reset(); + } + } + /*if ((SyncExceptionCause.SYNC_PROXY_CYCLED != cause) && mLogAdapter != null) { + mLogAdapter.logMessage("onProxyClosed: " + info, Log.ERROR, e, true); + }*/ + } + } + + public void reset() { + if (mSyncProxy == null) { + return; + } + // In case we run exit() - this is a quick marker of exiting. + if (mProxyServiceEvent != null) { + return; + } + try { + mSyncProxy.resetProxy(); + } catch (SyncException e1) { + e1.printStackTrace(); + //something goes wrong, & the proxy returns as null, stop the service. + //do not want a running service with a null proxy + if (mSyncProxy == null) { + stopServiceBySelf(); + } + } + } + + /** + * Restarting SyncProxyALM. For example after changing transport type + */ + public void restart() { + Log.i(TAG, "ProxyService.Restart SyncProxyALM."); + disposeSyncProxy(); + startProxyIfNetworkConnected(); + } + + @Override + public void onError(String info, Throwable e) { + createErrorMessageForAdapter("******onProxyError******", e); + createErrorMessageForAdapter("Proxy error info: " + info); + } + + /** + * ****************************** + * * SYNC AppLink Base Callback's ** + * ******************************* + */ + @Override + public void onAddSubMenuResponse(AddSubMenuResponse response) { + createDebugMessageForAdapter(response); + final SyncProxyTester mainActivity = SyncProxyTester.getInstance(); + final boolean success = response.getSuccess(); + mainActivity.runOnUiThread(new Runnable() { + @Override + public void run() { + mainActivity.onAddSubMenuResponse(success); + } + }); + + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onCreateInteractionChoiceSetResponse(CreateInteractionChoiceSetResponse response) { + createDebugMessageForAdapter(response); + final SyncProxyTester mainActivity = SyncProxyTester.getInstance(); + final boolean success = response.getSuccess(); + mainActivity.runOnUiThread(new Runnable() { + @Override + public void run() { + mainActivity.onCreateChoiceSetResponse(success); + } + }); + + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onDeleteCommandResponse(DeleteCommandResponse response) { + createDebugMessageForAdapter(response); + final SyncProxyTester mainActivity = SyncProxyTester.getInstance(); + final boolean success = response.getSuccess(); + mainActivity.runOnUiThread(new Runnable() { + @Override + public void run() { + mainActivity.onDeleteCommandResponse(success); + } + }); + + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onDeleteInteractionChoiceSetResponse(DeleteInteractionChoiceSetResponse response) { + createDebugMessageForAdapter(response); + final SyncProxyTester mainActivity = SyncProxyTester.getInstance(); + final boolean success = response.getSuccess(); + mainActivity.runOnUiThread(new Runnable() { + @Override + public void run() { + mainActivity.onDeleteChoiceSetResponse(success); + } + }); + + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onDeleteSubMenuResponse(DeleteSubMenuResponse response) { + createDebugMessageForAdapter(response); + final SyncProxyTester mainActivity = SyncProxyTester.getInstance(); + final boolean success = response.getSuccess(); + mainActivity.runOnUiThread(new Runnable() { + @Override + public void run() { + mainActivity.onDeleteSubMenuResponse(success); + } + }); + + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onEncodedSyncPDataResponse(EncodedSyncPDataResponse response) { + Log.i("syncp", "onEncodedSyncPDataResponse: " + response.getInfo() + response.getResultCode() + response.getSuccess()); + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onResetGlobalPropertiesResponse(ResetGlobalPropertiesResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onSetMediaClockTimerResponse(SetMediaClockTimerResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onSpeakResponse(SpeakResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onSubscribeButtonResponse(SubscribeButtonResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onUnsubscribeButtonResponse(UnsubscribeButtonResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onOnDriverDistraction(OnDriverDistraction notification) { + createDebugMessageForAdapter(notification); + } + + @Override + public void onGenericResponse(GenericResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + /** + * ****************************** + * * SYNC AppLink Soft Button Image Callback's ** + * ******************************* + */ + @Override + public void onPutFileResponse(PutFileResponse response) { + createDebugMessageForAdapter(response); + int mCorrelationId = response.getCorrelationID(); + if (mCorrelationId == mAwaitingInitIconResponseCorrelationID && getAutoSetAppIconFlag()) { + setAppIcon(); + } + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(mCorrelationId, response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + mPutFileTransferManager.removePutFileFromAwaitArray(mCorrelationId); + } + + @Override + public void onDeleteFileResponse(DeleteFileResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onListFilesResponse(ListFilesResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + //Log.d(TAG, "ListFiles:" + response.getFilenames().toString()); + } + + @Override + public void onSetAppIconResponse(SetAppIconResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onOnButtonEvent(OnButtonEvent notification) { + createDebugMessageForAdapter(notification); + } + + @Override + public void onOnButtonPress(OnButtonPress notification) { + createDebugMessageForAdapter(notification); + switch (notification.getButtonName()) { + case OK: + playPauseAnnoyingRepetitiveAudio(); + break; + case SEEKLEFT: + break; + case SEEKRIGHT: + break; + case TUNEUP: + break; + case TUNEDOWN: + break; + default: + break; + } + } + + /** + * ****************************** + * * SYNC AppLink Updated Callback's ** + * ******************************* + */ + @Override + public void onAddCommandResponse(AddCommandResponse response) { + createDebugMessageForAdapter(response); + final SyncProxyTester mainActivity = SyncProxyTester.getInstance(); + final boolean success = response.getSuccess(); + mainActivity.runOnUiThread(new Runnable() { + @Override + public void run() { + mainActivity.onAddCommandResponse(success); + } + }); + + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onAlertResponse(AlertResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onPerformInteractionResponse(PerformInteractionResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onSetGlobalPropertiesResponse(SetGlobalPropertiesResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onShowResponse(ShowResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + /** + * ****************************** + * * SYNC AppLink New Callback's ** + * ******************************* + */ + @Override + public void onSliderResponse(SliderResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onScrollableMessageResponse(ScrollableMessageResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onChangeRegistrationResponse(ChangeRegistrationResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onSetDisplayLayoutResponse(SetDisplayLayoutResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onOnLanguageChange(OnLanguageChange notification) { + createDebugMessageForAdapter(notification); + } + + /** + * ****************************** + * * SYNC AppLink Audio Pass Thru Callback's ** + * ******************************* + */ + @Override + public void onPerformAudioPassThruResponse(PerformAudioPassThruResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + + final SyncProxyTester mainActivity = SyncProxyTester.getInstance(); + final Result result = response.getResultCode(); + mainActivity.runOnUiThread(new Runnable() { + @Override + public void run() { + mainActivity.onPerformAudioPassThruResponse(result); + } + }); + } + + @Override + public void onEndAudioPassThruResponse(EndAudioPassThruResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + + final SyncProxyTester mainActivity = SyncProxyTester.getInstance(); + final Result result = response.getResultCode(); + mainActivity.runOnUiThread(new Runnable() { + @Override + public void run() { + mainActivity.onEndAudioPassThruResponse(result); + } + }); + } + + @Override + public void onOnAudioPassThru(OnAudioPassThru notification) { + createDebugMessageForAdapter(notification); + final SyncProxyTester mainActivity = SyncProxyTester.getInstance(); + final byte[] aptData = notification.getAPTData(); + mainActivity.runOnUiThread(new Runnable() { + @Override + public void run() { + mainActivity.onAudioPassThru(aptData); + } + }); + } + + /** + * ****************************** + * * SYNC AppLink Vehicle Data Callback's ** + * ******************************* + */ + @Override + public void onSubscribeVehicleDataResponse(SubscribeVehicleDataResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onUnsubscribeVehicleDataResponse(UnsubscribeVehicleDataResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onGetVehicleDataResponse(GetVehicleDataResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onReadDIDResponse(ReadDIDResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onGetDTCsResponse(GetDTCsResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onOnVehicleData(OnVehicleData notification) { + createDebugMessageForAdapter(notification); + } + + /** + * ****************************** + * * SYNC AppLink TBT Callback's ** + * ******************************* + */ + @Override + public void onShowConstantTBTResponse(ShowConstantTBTResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onAlertManeuverResponse(AlertManeuverResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onUpdateTurnListResponse(UpdateTurnListResponse response) { + createDebugMessageForAdapter(response); + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onSystemRequestResponse(SystemRequestResponse response) { + createDebugMessageForAdapter(response); + + if (isModuleTesting()) { + ModuleTest.responses.add( + new Pair<Integer, Result>(response.getCorrelationID(), + response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onMobileNaviStart() { + if (mProxyServiceEvent != null) { + mProxyServiceEvent.onServiceStart(ServiceType.Mobile_Nav, (byte) -1); + } + } + + @Override + public void onAudioServiceStart() { + if (mProxyServiceEvent != null) { + mProxyServiceEvent.onServiceStart(ServiceType.Audio_Service, (byte) -1); + } + } + + @Override + public void onMobileNavAckReceived(int frameReceivedNumber) { + if (mProxyServiceEvent != null) { + mProxyServiceEvent.onAckReceived(frameReceivedNumber, ServiceType.Mobile_Nav); + } + } + + @Override + public void onStartServiceNackReceived(ServiceType serviceType) { + if (mProxyServiceEvent != null) { + mProxyServiceEvent.onStartServiceNackReceived(serviceType); + } + } + + @Override + public void onOnTouchEvent(OnTouchEvent notification) { + final OnTouchEvent event = notification; + createDebugMessageForAdapter(notification); + final SyncProxyTester mainActivity = SyncProxyTester.getInstance(); + mainActivity.runOnUiThread(new Runnable() { + @Override + public void run() { + mainActivity.onTouchEventReceived(event); + } + }); + + } + + @Override + public void onKeyboardInput(OnKeyboardInput msg) { + final OnKeyboardInput event = msg; + createDebugMessageForAdapter(msg); + final SyncProxyTester mainActivity = SyncProxyTester.getInstance(); + mainActivity.runOnUiThread(new Runnable() { + @Override + public void run() { + mainActivity.onKeyboardInputReceived(event); + } + }); + } + + @Override + public void onOnSystemRequest(OnSystemRequest notification) { + createDebugMessageForAdapter(notification); + } + + @Override + public void onRegisterAppRequest(RegisterAppInterface msg) { + Log.i(TAG, "OnRegisterAppRequest: " + msg.toString()); + createDebugMessageForAdapter(msg); + } + + @Override + public void onAppUnregisteredAfterLanguageChange(OnLanguageChange msg) { + String message = + String.format("OnAppInterfaceUnregistered (LANGUAGE_CHANGE) from %s to %s", + msg.getLanguage(), msg.getHmiDisplayLanguage()); + createDebugMessageForAdapter(message); + mSyncProxy.resetLanguagesDesired(msg.getLanguage(), msg.getHmiDisplayLanguage()); + } + + @Override + public void onAppUnregisteredReason(AppInterfaceUnregisteredReason reason) { + createDebugMessageForAdapter("onAppUnregisteredReason:" + reason); + } + + @Override + public void onProtocolServiceEnded(final ServiceType serviceType, final Byte version, + final String correlationID) { + String response = "EndService Ack received; Session Type " + serviceType.getName() + "; " + + "Session ID " + version + "; Correlation ID " + correlationID; + createDebugMessageForAdapter(response); + + if (mProxyServiceEvent != null) { + mProxyServiceEvent.onServiceEnd(serviceType); + } + if (serviceType == ServiceType.RPC) { + mLogAdapter.logMessage("RPC service stopped", true); + + if (mProxyServiceEvent != null) { + mProxyServiceEvent.onDisposeComplete(); + } + + if (mCloseSessionCallback != null) { + mCloseSessionCallback.onCloseSessionComplete(); + } + } + } + + @Override + public void onSessionStarted(final byte sessionID, final String correlationID) { + Log.d(TAG, "SessionStart:" + sessionID + ", mProxyServiceEvent:" + mProxyServiceEvent); + if (mProxyServiceEvent != null) { + mProxyServiceEvent.onServiceStart(ServiceType.RPC, sessionID); + } + } + + @Override + public void onOnTBTClientState(OnTBTClientState notification) { + createDebugMessageForAdapter(notification); + } + + /** + * ****************************** + * * SYNC AppLink Policies Callback's ** + * ******************************* + */ + @Override + public void onOnPermissionsChange(OnPermissionsChange notification) { + createDebugMessageForAdapter(notification); + } + + EncodedSyncPDataHeader encodedSyncPDataHeaderfromGPS; + + @Override + public void onOnEncodedSyncPData(OnEncodedSyncPData notification) { + Log.i("syncp", "MessageType: " + notification.getMessageType()); + + createDebugMessageForAdapter(notification); + + EncodedSyncPDataHeader encodedSyncPDataHeader; + try { + encodedSyncPDataHeader = EncodedSyncPDataHeader.parseEncodedSyncPDataHeader( + Base64.decode(notification.getData().get(0))); + } catch (IOException e) { + Log.e(TAG, "Can't decode base64 string", e); + return; + } + + if (encodedSyncPDataHeader.getServiceType() == 3 && encodedSyncPDataHeader.getCommandType() == 1) { + writeToFile(encodedSyncPDataHeader.getPayload()); + + Log.i("EncodedSyncPDataHeader", "Protocol Version: " + encodedSyncPDataHeader.getProtocolVersion()); + Log.i("EncodedSyncPDataHeader", "Response Required: " + encodedSyncPDataHeader.getResponseRequired()); + Log.i("EncodedSyncPDataHeader", "High Bandwidth: " + encodedSyncPDataHeader.getHighBandwidth()); + Log.i("EncodedSyncPDataHeader", "Signed: " + encodedSyncPDataHeader.getSigned()); + Log.i("EncodedSyncPDataHeader", "Encrypted: " + encodedSyncPDataHeader.getEncrypted()); + Log.i("EncodedSyncPDataHeader", "Payload Size: " + encodedSyncPDataHeader.getPayloadSize()); + Log.i("EncodedSyncPDataHeader", "Has ESN: " + encodedSyncPDataHeader.getHasESN()); + Log.i("EncodedSyncPDataHeader", "Service Type: " + encodedSyncPDataHeader.getServiceType()); + Log.i("EncodedSyncPDataHeader", "Command Type: " + encodedSyncPDataHeader.getCommandType()); + Log.i("EncodedSyncPDataHeader", "CPU Destination: " + encodedSyncPDataHeader.getCPUDestination()); + Log.i("EncodedSyncPDataHeader", "Encryption Key Index: " + encodedSyncPDataHeader.getEncryptionKeyIndex()); + + byte[] tempESN = encodedSyncPDataHeader.getESN(); + String stringESN = ""; + for (int i = 0; i < 8; i++) stringESN += tempESN[i]; + Log.i("EncodedSyncPDataHeader", "ESN: " + stringESN); + + try { + Log.i("EncodedSyncPDataHeader", "Module Message ID: " + encodedSyncPDataHeader.getModuleMessageID()); + } catch (Exception e) { + } + try { + Log.i("EncodedSyncPDataHeader", "Server Message ID: " + encodedSyncPDataHeader.getServerMessageID()); + } catch (Exception e) { + } + try { + Log.i("EncodedSyncPDataHeader", "Message Status: " + encodedSyncPDataHeader.getMessageStatus()); + } catch (Exception e) { + } + + //create header for syncp packet + if (encodedSyncPDataHeader.getHighBandwidth()) { + byte[] tempIV = encodedSyncPDataHeader.getIV(); + String stringIV = ""; + for (int i = 0; i < 16; i++) stringIV += tempIV[i]; + Log.i("EncodedSyncPDataHeader", "IV: " + stringIV); + + byte[] tempPayload = encodedSyncPDataHeader.getPayload(); + String stringPayload = ""; + for (int i = 0; i < encodedSyncPDataHeader.getPayloadSize(); i++) + stringPayload += tempPayload[i]; + Log.i("EncodedSyncPDataHeader", "Payload: " + stringPayload); + + byte[] tempSignatureTag = encodedSyncPDataHeader.getSignatureTag(); + String stringSignatureTag = ""; + for (int i = 0; i < 16; i++) stringSignatureTag += tempSignatureTag[i]; + Log.i("EncodedSyncPDataHeader", "Signature Tag: " + stringSignatureTag); + } else { + byte[] tempIV = encodedSyncPDataHeader.getIV(); + String stringIV = ""; + for (int i = 0; i < 8; i++) stringIV += tempIV[i]; + Log.i("EncodedSyncPDataHeader", "IV: " + stringIV); + + byte[] tempPayload = encodedSyncPDataHeader.getPayload(); + String stringPayload = ""; + for (int i = 0; i < encodedSyncPDataHeader.getPayloadSize(); i++) + stringPayload += tempPayload[i]; + Log.i("EncodedSyncPDataHeader", "Payload: " + stringPayload); + + byte[] tempSignatureTag = encodedSyncPDataHeader.getSignatureTag(); + String stringSignatureTag = ""; + for (int i = 0; i < 8; i++) stringSignatureTag += tempSignatureTag[i]; + Log.i("EncodedSyncPDataHeader", "Signature Tag: " + stringSignatureTag); + } + + encodedSyncPDataHeaderfromGPS = encodedSyncPDataHeader; + if (mLogAdapter != null) { + SyncProxyTester.setESN(tempESN); + } + if (PoliciesTesterActivity.getInstance() != null) { + PoliciesTesterActivity.setESN(tempESN); + PoliciesTesterActivity.setHeader(encodedSyncPDataHeader); + } + } + + if (encodedSyncPDataHeader.getServiceType() == 7) { + writeToFile(encodedSyncPDataHeader.getPayload()); + } + } + + public void writeToFile(Object writeME) { + //FileInputStream fin; + try { + //fin = new FileInputStream("/sdcard/" + "policiesResults.txt"); + //InputStreamReader isr = new InputStreamReader(fin); + //String outFile = "/sdcard/" + mChosenFile.substring(0, mChosenFile.length() - 4) + ".csv"; + //String outFile = "/sdcard/" + "policiesResults.txt"; + String outFile = Environment.getExternalStorageDirectory().getPath() + "/policiesResults.txt"; + File out = new File(outFile); + FileWriter writer = new FileWriter(out); + writer.flush(); + + //writer.write("yay" + "\n"); + writer.write(writeME.toString()); + //writer.write("double yay" + "\n"); + + writer.close(); + } catch (FileNotFoundException e) { + Log.i("syncp", "FileNotFoundException: " + e); + Log.e(TAG, e.toString()); + } catch (IOException e) { + Log.i("syncp", "IOException: " + e); + Log.e(TAG, e.toString()); + } + } + + @Override + public IBinder onBind(Intent intent) { + createInfoMessageForAdapter("Service on bind"); + return mBinder; + } + + @Override + public void onRegisterAppInterfaceResponse(RegisterAppInterfaceResponse response) { + createDebugMessageForAdapter(response); + + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + + try { + processRegisterAppInterfaceResponse(response); + } catch (SyncException e) { + createErrorMessageForAdapter("Can not process RAIResponse:" + e.getMessage()); + } + } + + @Override + public void onUnregisterAppInterfaceResponse(UnregisterAppInterfaceResponse response) { + createDebugMessageForAdapter(response); + + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onSyncPDataResponse(SyncPDataResponse response) { + createDebugMessageForAdapter(response); + + if (isModuleTesting()) { + ModuleTest.responses.add(new Pair<Integer, Result>(response.getCorrelationID(), response.getResultCode())); + synchronized (mTesterMain.getThreadContext()) { + mTesterMain.getThreadContext().notify(); + } + } + } + + @Override + public void onOnSyncPData(OnSyncPData notification) { + createDebugMessageForAdapter(notification); + } + + private void resendUnsentPutFiles() { + SparseArray<PutFile> unsentPutFiles = mPutFileTransferManager.getCopy(); + mPutFileTransferManager.clear(); + for (int i = 0; i < unsentPutFiles.size(); i++) { + commandPutFile(unsentPutFiles.valueAt(i)); + } + unsentPutFiles.clear(); + } + + private void stopServiceBySelf() { + Log.i(TAG, ProxyService.class.getSimpleName() + " Stop Service By Self"); + stopSelf(); + } + + // TODO : Set command factory in separate place + /** + * Commands Section + */ + + /** + * Create and send ListFiles command + */ + + /** + * Create and send ListFiles command + */ + public void commandListFiles() { + try { + mSyncProxy.listFiles(getNextCorrelationID()); + if (mLogAdapter != null) { + mLogAdapter.logMessage("ListFiles sent", true); + } + } catch (SyncException e) { + mLogAdapter.logMessage("ListFiles send error: " + e, Log.ERROR, e); + } + } + + /** + * Create and send PutFile command + * + * @param putFile PurFile to be send + */ + public void commandPutFile(PutFile putFile) { + commandPutFile(null, null, null, getNextCorrelationID(), null, putFile); + } + + /** + * Create and send PutFile command + * + * @param fileType Type of the File + * @param syncFileName Name of the File + * @param bulkData Data of the File + */ + public void commandPutFile(FileType fileType, String syncFileName, byte[] bulkData) { + commandPutFile(fileType, syncFileName, bulkData, -1, null, null); + } + + /** + * Create and send PutFile command + * + * @param fileType Type of the File + * @param syncFileName Name of the File + * @param bulkData Data of the File + * @param correlationId Unique identifier of the command + */ + public void commandPutFile(FileType fileType, String syncFileName, byte[] bulkData, + int correlationId) { + commandPutFile(fileType, syncFileName, bulkData, correlationId, null, null); + } + + /** + * Create and send PutFile command + * + * @param fileType Type of the File + * @param syncFileName Name of the File + * @param bulkData Data of the File + * @param correlationId Unique identifier of the command + * @param doSetPersistent + */ + public void commandPutFile(FileType fileType, String syncFileName, byte[] bulkData, + int correlationId, Boolean doSetPersistent) { + commandPutFile(fileType, syncFileName, bulkData, correlationId, doSetPersistent, null); + } + + /** + * Create and send PutFile command + * + * @param fileType Type of the File + * @param syncFileName Name of the File + * @param bulkData Data of the File + * @param correlationId Unique identifier of the command + * @param doSetPersistent + * @param putFile PurFile to be send + */ + public void commandPutFile(FileType fileType, String syncFileName, + byte[] bulkData, int correlationId, + Boolean doSetPersistent, PutFile putFile) { + commandPutFile(fileType, syncFileName, bulkData, correlationId, + doSetPersistent, null, null, null, putFile); + } + + /** + * Create and send PutFile command + * + * @param fileType Type of the File + * @param syncFileName Name of the File + * @param bulkData Data of the File + * @param correlationId Unique identifier of the command + * @param doSetPersistent + * @param isSystemFile + * @param length + * @param offset + * @param putFile PurFile to be send + */ + public void commandPutFile(FileType fileType, String syncFileName, + byte[] bulkData, int correlationId, + Boolean doSetPersistent, Boolean isSystemFile, + Integer length, Integer offset, + PutFile putFile) { + int mCorrelationId = correlationId; + if (correlationId == -1) { + mCorrelationId = getNextCorrelationID(); + } + + PutFile newPutFile = RPCRequestFactory.buildPutFile(); + + if (putFile == null) { + newPutFile.setFileType(fileType); + newPutFile.setSyncFileName(syncFileName); + if (doSetPersistent != null) { + newPutFile.setPersistentFile(doSetPersistent); + } + + if (isSystemFile != null) { + newPutFile.setSystemFile(isSystemFile); + } + + if (length != null) { + newPutFile.setLength(length); + } + + if (offset != null) { + newPutFile.setOffset(offset); + } + + newPutFile.setBulkData(bulkData); + } else { + newPutFile = putFile; + } + + newPutFile.setCorrelationID(mCorrelationId); + + mPutFileTransferManager.addPutFileToAwaitArray(mCorrelationId, newPutFile); + + syncProxySendPutFilesResumable(newPutFile); + + //mAwaitingInitIconResponseCorrelationID = 0; + } + + /** + * Call a method from SDK to send <b>SubscribeButton</b> request + * + * @param buttonName {@link com.ford.syncV4.proxy.rpc.enums.ButtonName} + */ + public void commandSubscribeButtonPredefined(ButtonName buttonName, int correlationId) { + SubscribeButton subscribeButton = RPCRequestFactory.buildSubscribeButton(); + subscribeButton.setCorrelationID(correlationId); + subscribeButton.setButtonName(buttonName); + + syncProxySendRPCRequest(subscribeButton); + } + + /** + * Call a method from SDK to send <b>SubscribeButton</b> request which will be used in application + * resumption. + * + * @param correlationId Unique identifier of the command + * @param buttonName {@link com.ford.syncV4.proxy.rpc.enums.ButtonName} + */ + public void commandSubscribeButtonResumable(ButtonName buttonName, int correlationId) { + SubscribeButton subscribeButton = RPCRequestFactory.buildSubscribeButton(); + subscribeButton.setCorrelationID(correlationId); + subscribeButton.setButtonName(buttonName); + + syncProxySendRPCRequestResumable(subscribeButton); + } + + /** + * Call a method from SDK to send <b>UnsubscribeVehicleData</b> request. + * + * @param unsubscribeVehicleData {@link com.ford.syncV4.proxy.rpc.UnsubscribeVehicleData} + */ + public void commandUnsubscribeVehicleInterface(UnsubscribeVehicleData unsubscribeVehicleData) { + syncProxySendRPCRequest(unsubscribeVehicleData); + } + + /** + * Call a method from SDK to send <b>SubscribeVehicleData</b> request which will be used in + * application resumption. + * + * @param subscribeVehicleData {@link com.ford.syncV4.proxy.rpc.SubscribeVehicleData} + */ + public void commandSubscribeVehicleInterfaceResumable(SubscribeVehicleData subscribeVehicleData) { + syncProxySendRPCRequestResumable(subscribeVehicleData); + } + + /** + * Call a method from SDK to send <b>AddCommand</b> request which will be used in application + * resumption. + * + * @param commandId Id of the command + * @param vrCommands Vector of the VR Commands + * @param menuName Name of the Menu + */ + public void commandAddCommandResumable(Integer commandId, Vector<String> vrCommands, + String menuName) { + AddCommand addCommand = RPCRequestFactory.buildAddCommand(commandId, menuName, vrCommands, + getNextCorrelationID()); + syncProxySendRPCRequestResumable(addCommand); + } + + /** + * Call a method from SDK to send <b>AddCommand</b> request + * + * @param commandId Id of the command + * @param vrCommands Vector of the VR Commands + * @param menuName Name of the Menu + */ + public void commandAddCommandPredefined(Integer commandId, Vector<String> vrCommands, + String menuName) { + AddCommand addCommand = RPCRequestFactory.buildAddCommand(commandId, menuName, vrCommands, + getNextCorrelationID()); + syncProxySendRPCRequest(addCommand); + } + + /** + * Call a method from SDK to send <b>AddCommand</b> request which will be used in application + * resumption. + * + * @param addCommand {@link com.ford.syncV4.proxy.rpc.AddCommand} object + */ + public void commandAddCommandResumable(AddCommand addCommand) { + syncProxySendRPCRequestResumable(addCommand); + } + + /** + * Call a method from SDK to send <b>AddSubMenu</b> request which will be used in application + * resumption. + * + * @param setGlobalProperties {@link com.ford.syncV4.proxy.rpc.SetGlobalProperties} + */ + public void commandSetGlobalPropertiesResumable(SetGlobalProperties setGlobalProperties) { + syncProxySendRPCRequestResumable(setGlobalProperties); + } + + /** + * Call a method from SDK to send <b>AddSubMenu</b> request which will be used in application + * resumption. + * + * @param addSubMenu {@link com.ford.syncV4.proxy.rpc.AddSubMenu} object + */ + public void commandAddSubMenuResumable(AddSubMenu addSubMenu) { + syncProxySendRPCRequestResumable(addSubMenu); + } + + /** + * Call a method from SDK to create and send <b>CreateInteractionChoiceSet</b> request which + * will be used in application resumption. + * + * @param choiceSet Set of the {@link com.ford.syncV4.proxy.rpc.Choice} objects + * @param interactionChoiceSetID Id of the interaction Choice set + * @param correlationID correlation Id + */ + public void commandCreateInteractionChoiceSetResumable(Vector<Choice> choiceSet, + Integer interactionChoiceSetID, + Integer correlationID) { + + CreateInteractionChoiceSet createInteractionChoiceSet = + RPCRequestFactory.buildCreateInteractionChoiceSet(choiceSet, + interactionChoiceSetID, correlationID); + syncProxySendRPCRequestResumable(createInteractionChoiceSet); + } + + /** + * SyncProxy section, transfer call methods from Application to SyncProxy + */ + + public void syncProxyStopAudioDataTransfer() { + if (mSyncProxy != null) { + mSyncProxy.stopAudioDataTransfer(); + } + } + + public void syncProxyStopH264() { + if (mSyncProxy != null) { + mSyncProxy.stopH264(); + } + } + + public void syncProxyCloseSession(boolean keepConnection) { + if (mSyncProxy != null) { + mSyncProxy.closeSession(keepConnection); + } + } + + public void syncProxyOpenSession() throws SyncException { + if (mSyncProxy != null) { + if (mSyncProxy.getIsConnected()) { + mSyncProxy.openSession(); + } else { + mSyncProxy.initializeProxy(); + } + } + } + + public void syncProxyStartAudioService(Session session) { + if (mSyncProxy != null && mSyncProxy.getSyncConnection() != null) { + mSyncProxy.getSyncConnection().startAudioService(session); + } + } + + public void syncProxyStopAudioService() { + if (mSyncProxy != null) { + mSyncProxy.stopAudioService(); + } + } + + public OutputStream syncProxyStartAudioDataTransfer() { + if (mSyncProxy != null) { + return mSyncProxy.startAudioDataTransfer(); + } + return null; + } + + /** + * This method is send RPC Request to the Sync Proxy + * + * @param request object of {@link com.ford.syncV4.proxy.RPCRequest} type + */ + public void syncProxySendRPCRequest(RPCRequest request) { + if (request == null) { + createErrorMessageForAdapter("RPC request is NULL"); + return; + } + try { + if (request.getFunctionName().equals(Names.RegisterAppInterface)) { + syncProxySendRegisterRequest((RegisterAppInterface) request); + } else { + mSyncProxy.sendRPCRequest(request); + } + createDebugMessageForAdapter(request); + } catch (SyncException e) { + createErrorMessageForAdapter("RPC request '" + request.getFunctionName() + "'" + + " send error"); + } + } + + /** + * This method is for the requests on which resumption is depends on. All the requests will be + * stored in the collection in order to re-use them when resumption will have place. + * + * @param request {@link com.ford.syncV4.proxy.RPCRequest} object + */ + public void syncProxySendRPCRequestResumable(RPCRequest request) { + if (request == null) { + createErrorMessageForAdapter("Resumable RPC request is NULL"); + return; + } + + if (mSyncProxy.getIsConnected()) { + mRpcRequestsResumableManager.addRequestConnected(request); + } else { + mRpcRequestsResumableManager.addRequestDisconnected(request); + } + + syncProxySendRPCRequest(request); + } + + /** + * + * + * @param putFile + */ + public void syncProxySendPutFilesResumable(PutFile putFile) { + if (putFile == null) { + createErrorMessageForAdapter("Resumable PuFile is NULL"); + return; + } + + //mRpcRequestsResumableManager.addPutFile(putFile); + + syncProxySendRPCRequest(putFile); + } + + private void syncProxySendRegisterRequest(RegisterAppInterface msg) throws SyncException { + if (mSyncProxy != null) { + // TODO it's seems stupid in order to register send onTransportConnected + mSyncProxy.updateRegisterAppInterfaceParameters(msg); + mSyncProxy.getSyncConnection().onTransportConnected(); + } + } + + public byte syncProxyGetWiProVersion() { + if (mSyncProxy != null) { + return mSyncProxy.getWiProVersion(); + } + return 0; + } + + public void syncProxyStartMobileNavService(Session session) { + if (mSyncProxy != null && mSyncProxy.getSyncConnection() != null) { + mSyncProxy.getSyncConnection().startMobileNavService(session); + } + } + + public OutputStream syncProxyStartH264() { + if (mSyncProxy != null) { + return mSyncProxy.startH264(); + } + return null; + } + + public void syncProxyStopMobileNaviService() { + if (mSyncProxy != null) { + mSyncProxy.stopMobileNaviService(); + } + } + + public IJsonRPCMarshaller syncProxyGetJsonRPCMarshaller() { + if (mSyncProxy != null) { + return mSyncProxy.getJsonRPCMarshaller(); + } + return null; + } + + public void syncProxySetJsonRPCMarshaller(IJsonRPCMarshaller jsonRPCMarshaller) { + if (mSyncProxy != null) { + mSyncProxy.setJsonRPCMarshaller(jsonRPCMarshaller); + } + } + + private void setAppIcon() { + SetAppIcon setAppIcon = RPCRequestFactory.buildSetAppIcon(); + setAppIcon.setSyncFileName(ICON_SYNC_FILENAME); + setAppIcon.setCorrelationID(getNextCorrelationID()); + + syncProxySendRPCRequest(setAppIcon); + + mAwaitingInitIconResponseCorrelationID = 0; + } + + /** + * Process a response of the {@link com.ford.syncV4.proxy.rpc.RegisterAppInterface} request + * + * @param response {@link com.ford.syncV4.proxy.rpc.RegisterAppInterfaceResponse} object + */ + private void processRegisterAppInterfaceResponse(RegisterAppInterfaceResponse response) + throws SyncException { + + if (!response.getSuccess()) { + return; + } + + if (response.getResultCode() == Result.SUCCESS) { + //mRpcRequestsResumableManager.sendAllPutFiles(); + mRpcRequestsResumableManager.sendAllRequestsDisconnected(); + } else if (response.getResultCode() == Result.RESUME_FAILED) { + //mRpcRequestsResumableManager.sendAllPutFiles(); + mRpcRequestsResumableManager.sendAllRequestsConnected(); + mRpcRequestsResumableManager.sendAllRequestsDisconnected(); + } + + //mRpcRequestsResumableManager.cleanAllPutFiles(); + mRpcRequestsResumableManager.cleanAllRequestsConnected(); + mRpcRequestsResumableManager.cleanAllRequestsDisconnected(); + + // Restore a PutFile which has not been sent + resendUnsentPutFiles(); + // Restore Services + mSyncProxy.restoreServices(); + } + + // TODO: Reconsider this section, this is a first step to optimize log procedure + + /** + * Logger section. Send log message to adapter and log it to the ADB + */ + + private void createErrorMessageForAdapter(Object messageObject) { + createErrorMessageForAdapter(messageObject, null); + } + + private void createErrorMessageForAdapter(Object messageObject, Throwable throwable) { + if (mLogAdapter == null) { + Log.w(TAG, "LogAdapter is null"); + } + if (mLogAdapter != null) { + if (throwable != null) { + mLogAdapter.logMessage(messageObject, Log.ERROR, throwable, true); + } else { + mLogAdapter.logMessage(messageObject, Log.ERROR, true); + } + } else { + if (throwable != null) { + Log.e(TAG, messageObject.toString(), throwable); + } else { + Log.e(TAG, messageObject.toString()); + } + } + } + + private void createInfoMessageForAdapter(Object messageObject) { + createMessageForAdapter(messageObject, Log.INFO); + } + + private void createDebugMessageForAdapter(Object messageObject) { + createMessageForAdapter(messageObject, Log.DEBUG); + } + + private void createMessageForAdapter(Object messageObject, Integer type) { + if (mLogAdapter == null) { + Log.w(TAG, "LogAdapter is null"); + } + if (mLogAdapter != null) { + mLogAdapter.logMessage(messageObject, type, true); + } else { + if (type == Log.DEBUG) { + Log.d(TAG, messageObject.toString()); + } else if (type == Log.INFO) { + Log.i(TAG, messageObject.toString()); + } + } + } + + @Override + public void onUSBNoSuchDeviceException() { + final SyncProxyTester mainActivity = SyncProxyTester.getInstance(); + if (mainActivity != null) { + mainActivity.onUSBNoSuchDeviceException(); + } + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/ProxyServiceBinder.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/ProxyServiceBinder.java new file mode 100644 index 000000000..48697c22f --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/ProxyServiceBinder.java @@ -0,0 +1,22 @@ +package com.ford.syncV4.android.service; + +import android.os.Binder; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 1/28/14 + * Time: 10:45 AM + */ +public class ProxyServiceBinder extends Binder { + + private ProxyService mProxyService; + + public ProxyServiceBinder(ProxyService proxyService) { + mProxyService = proxyService; + } + + public ProxyService getService() { + return mProxyService; + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/ProxyServiceConnectionProxy.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/ProxyServiceConnectionProxy.java new file mode 100644 index 000000000..30bfd2741 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/ProxyServiceConnectionProxy.java @@ -0,0 +1,46 @@ +package com.ford.syncV4.android.service; + +import android.content.ComponentName; +import android.os.IBinder; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 1/28/14 + * Time: 10:53 AM + */ +public class ProxyServiceConnectionProxy extends AppServiceConnectionProxyBase { + + private IProxyServiceConnection mProxyServiceConnection; + + public ProxyServiceConnectionProxy(IProxyServiceConnection sdlServiceConnection) { + if (sdlServiceConnection == null) { + throw new NullPointerException("Can't create ProxyServiceConnectionProxy with NULL parameter"); + } + mProxyServiceConnection = sdlServiceConnection; + } + + @Override + public void onServiceConnected(ComponentName name, IBinder service) { + super.onServiceConnected(name, service); + if (service instanceof ProxyServiceBinder) { + mProxyServiceConnection.onProxyServiceConnected((ProxyServiceBinder) service); + } + } + + @Override + public void onServiceDisconnected(ComponentName name) { + super.onServiceDisconnected(name); + if (name != null && name.getClassName() != null && name.getClassName().equals(ProxyService.class.getName())) { + mProxyServiceConnection.onProxyServiceDisconnected(); + } + } + + @Override + public String toString() { + return getClass().getSimpleName() + '@' + Integer.toHexString(hashCode()) + + " [holderClass: " + mProxyServiceConnection.getClass().getSimpleName() + "@" + + Integer.toHexString(mProxyServiceConnection.hashCode()) + + ", connected: " + isConnected() + "]"; + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/proxy/OnSystemRequestHandler.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/proxy/OnSystemRequestHandler.java new file mode 100644 index 000000000..857f6332a --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/service/proxy/OnSystemRequestHandler.java @@ -0,0 +1,125 @@ +package com.ford.syncV4.android.service.proxy; + +import android.os.Handler; +import android.os.Looper; +import android.util.Log; + +import com.ford.syncV4.android.R; +import com.ford.syncV4.android.adapters.LogAdapter; +import com.ford.syncV4.android.manager.AppPreferencesManager; +import com.ford.syncV4.android.policies.PolicyFilesManager; +import com.ford.syncV4.android.utils.AppUtils; +import com.ford.syncV4.exception.SyncException; +import com.ford.syncV4.proxy.rpc.enums.FileType; +import com.ford.syncV4.proxy.systemrequest.IOnSystemRequestHandler; +import com.ford.syncV4.proxy.systemrequest.ISystemRequestProxy; + +import java.util.Arrays; +import java.util.List; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 2/12/14 + * Time: 2:50 PM + */ +public class OnSystemRequestHandler implements IOnSystemRequestHandler { + + private LogAdapter mLogAdapter; + + public OnSystemRequestHandler(LogAdapter mLogAdapter) { + this.mLogAdapter = mLogAdapter; + } + + @Override + public void onFilesDownloadRequest(final ISystemRequestProxy proxy, List<String> urls, + FileType fileType) { + // TODO : Logging to be refactored + if (mLogAdapter != null) { + mLogAdapter.logMessage("files download request", Log.DEBUG, true); + } + + // Simulate Files downloading request and future processing + // Then, call appropriate method at provided callback which implement + // ISystemRequestProxy interface + + new Handler(Looper.getMainLooper()).postDelayed(new Runnable() { + @Override + public void run() { + final byte[] data = AppUtils.contentsOfResource(R.raw.audio_short); + try { + proxy.putSystemFile("system.update", data, FileType.AUDIO_WAVE); + } catch (SyncException e) { + // TODO : Logging to be refactored + if (mLogAdapter != null) { + mLogAdapter.logMessage("Can't upload system file:" + e.getMessage(), + Log.ERROR, true); + } + } + } + }, 500); + } + + @Override + public void onFileResumeRequest(final ISystemRequestProxy proxy, String filename, + final Integer offset, final Integer length, FileType fileType) { + // TODO : Logging to be refactored + if (mLogAdapter != null) { + mLogAdapter.logMessage("files resume request", Log.DEBUG, true); + } + + // Simulate Files download resumption request and future processing + // Then, call appropriate method at provided callback which implement + // ISystemRequestProxy interface + + new Handler(Looper.getMainLooper()).postDelayed(new Runnable() { + @Override + public void run() { + final byte[] data = Arrays.copyOfRange( + AppUtils.contentsOfResource(R.raw.audio_short), offset, offset + length); + try { + proxy.putSystemFile("system.update", data, offset, FileType.AUDIO_WAVE); + } catch (SyncException e) { + // TODO : Logging to be refactored + if (mLogAdapter != null) { + mLogAdapter.logMessage("Can't upload system file:" + e.getMessage(), + Log.ERROR, true); + } + } + } + }, 500); + } + + @Override + public void onPolicyTableSnapshotRequest(final ISystemRequestProxy proxy, byte[] data) { + // TODO : Logging to be refactored + if (data == null) { + if (mLogAdapter != null) { + mLogAdapter.logMessage("Policy Snapshot data is null", Log.ERROR, true); + } + return; + } + if (mLogAdapter != null) { + mLogAdapter.logMessage("Policy Table Snapshot download request", Log.DEBUG, true); + } + + PolicyFilesManager.savePolicyTableSnapshot(data); + + // Simulate Policy Table Snapshot file processing + // Then, call appropriate method at provided callback which implement + // ISystemRequestProxy interface + + if (!AppPreferencesManager.getPolicyTableUpdateAutoReplay()) { + return; + } + + new Handler(Looper.getMainLooper()).postDelayed(new Runnable() { + @Override + public void run() { + + PolicyFilesManager.sendPolicyTableUpdate(proxy, mLogAdapter); + + } + }, 500); + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/utils/AppUtils.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/utils/AppUtils.java new file mode 100644 index 000000000..3898d1f01 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/utils/AppUtils.java @@ -0,0 +1,121 @@ +package com.ford.syncV4.android.utils; + +import android.os.Looper; +import android.util.Log; + +import com.ford.syncV4.android.MainApp; + +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; + +/** + * Created with Android Studio. + * Author: Chernyshov Yuriy - Mobile Development + * Date: 1/30/14 + * Time: 2:15 PM + */ +public class AppUtils { + + private static final String TAG = "AppUtils"; + + public static boolean isRunningUIThread() { + return Looper.myLooper() == Looper.getMainLooper(); + } + + /** + * Returns the file contents from the specified resource. + * + * @param resource Resource id (in res/ directory) + * @return The resource file's contents + */ + public static byte[] contentsOfResource(int resource) { + return contentsOfResource(MainApp.getInstance().getResources().openRawResource(resource)); + } + + /** + * Read a File and return bytes array + * @param file + * @return + */ + public static byte[] contentsOfResource(File file) { + try { + return contentsOfResource(new FileInputStream(file)); + } catch (FileNotFoundException e) { + Log.e(TAG, "Contents Of Resource exception", e); + } + return new byte[0]; + } + + public static byte[] contentsOfResource(String fileName) { + return contentsOfResource(new File(fileName)); + } + + /** + * Save bytes to a file + * @param data + * @param filePath + * @return + */ + public static boolean saveDataToFile(byte[] data, String filePath) { + File mFile = new File(filePath); + Log.d(TAG, "Saving data to file '" + filePath + "', exists:" + mFile.exists()); + if (mFile.exists()) { + mFile.delete(); + } + FileOutputStream mFileOutputStream = null; + boolean result = false; + try { + mFileOutputStream = new FileOutputStream(mFile.getPath()); + mFileOutputStream.write(data); + + result = true; + } catch (IOException e) { + Log.e(TAG, "Save Data To File IOException", e); + } finally { + if (mFileOutputStream != null) { + try { + mFileOutputStream.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + return result; + } + + /** + * Read a content of the Input Stream into bytes array + * + * @param inputStream a stream of incoming bytes + * @return bytes array + */ + private static byte[] contentsOfResource(InputStream inputStream) { + try { + ByteArrayOutputStream byteArrayOutputStream = + new ByteArrayOutputStream(inputStream.available()); + final int bufferSize = 4096; + final byte[] buffer = new byte[bufferSize]; + int available; + while ((available = inputStream.read(buffer)) >= 0) { + byteArrayOutputStream.write(buffer, 0, available); + } + return byteArrayOutputStream.toByteArray(); + } catch (IOException e) { + Log.w(TAG, "Can't read file", e); + return null; + } finally { + if (inputStream != null) { + try { + inputStream.close(); + } catch (IOException e) { + Log.e(TAG, e.toString()); + } + } + } + } +}
\ No newline at end of file diff --git a/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/utils/StringUtils.java b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/utils/StringUtils.java new file mode 100644 index 000000000..533fc2564 --- /dev/null +++ b/SDL_Core/mobile/android/SyncProxyTester/src/main/java/com/ford/syncV4/android/utils/StringUtils.java @@ -0,0 +1,28 @@ +package com.ford.syncV4.android.utils; + +import java.util.Vector; + +/** + * Created by enikolsky on 2013-11-25. + */ +public class StringUtils { + public static final String DEFAULT_JOIN_STRING = ","; + + public static String joinStrings(Iterable<String> strings, + String joinString) { + StringBuilder sb = new StringBuilder(); + int i = 0; + for (String string : strings) { + if (i != 0) { + sb.append(joinString); + } + sb.append(string); + ++i; + } + return sb.toString(); + } + + public static String joinStrings(Iterable<String> strings) { + return joinStrings(strings, DEFAULT_JOIN_STRING); + } +} |