public class NavigationOverlayView extends ViewPager
        implements Navigator.OnManeuverChangedListener {

    private Navigator navigator;
    private ManeuverPagerAdapter adapter;

    private final OnPageChangeListener pageChangeListener = new SimpleOnPageChangeListener() {
        @Override
        public void onPageSelected(int position) {
            if (navigator != null) {
                ManeuverPair pair = adapter.getItem(position);
								// when the user manually advances the maneuver, make sure the navigator is updated as well
                navigator.setCurrentManeuver(pair.mainPos);
            }
        }
    };

    public NavigationOverlayView(Context context) {
        this(context, null);
    }

    public NavigationOverlayView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public void setNavigator(BuildingOptions building, Navigator navigator) {
        this.navigator = navigator;
        navigator.addOnManeuverChangedListener(this);


        List<ManeuverPair> pairs = new ArrayList<>();
        List<RouteManeuverOptions> maneuvers = this.navigator.getManeuvers();
        for (int i = 0; i < maneuvers.size(); i += 2) {
            ManeuverPair pair = new ManeuverPair();
            pair.mainPos = i;
            pair.mainManeuver = maneuvers.get(i);

            if (i + 1 < maneuvers.size()) {
                RouteManeuverOptions next = maneuvers.get(i + 1);
                if (next.isTurnManeuver() || next.isPortalManeuver()) {
                    pair.turnPos = i + 1;
                    pair.turnManeuver = next;
                } else {
                    i--;
                }
            }
            pairs.add(pair);
        }

        setAdapter(adapter = new ManeuverPagerAdapter(navigator));
        adapter.setManeuvers(building, pairs);
        addOnPageChangeListener(pageChangeListener);
        setCurrentItem(0);
        navigator.setCurrentManeuver(0);
    }

    @Override
    public void onManeuverChanged(Navigator navigator, int position) {
		// the user's position has triggered the Navigator to automatically update the current maneuver. Update the UI accordingly
        for (int i = 0; i < adapter.getCount(); i++) {
            ManeuverPair pair = adapter.getItem(i);
            if (pair.mainPos == position || pair.turnPos == position) {
                setCurrentItem(i);
                return;
            }
        }
    }

    @Override
    public void onRouteSnapFailed() {
        Log.e("OverlayView", "RouteSnapFailed");
    }

		// bundle maneuvers into pairs of a straight maneuver and a turn/floor change maneuver
    private static class ManeuverPair {
        int mainPos;
        int turnPos;
        RouteManeuverOptions mainManeuver;
        RouteManeuverOptions turnManeuver;
    }

    private static final class ManeuverPagerAdapter extends PagerAdapter {


        private final Navigator navigator;
        private final ManeuverDisplayHelper displayHelper;
        private final List<ManeuverPair> maneuvers = new ArrayList<>();

        public ManeuverPagerAdapter(Navigator navigator) {
            super();
            this.navigator = navigator;
            displayHelper = new ManeuverDisplayHelper();
        }

        @Override
        public int getCount() {
            return maneuvers.size();
        }

        public void setManeuvers(BuildingOptions building,
                Collection<? extends ManeuverPair> maneuvers) {
            displayHelper.setBuilding(building);
            this.maneuvers.clear();
            this.maneuvers.addAll(maneuvers);
            notifyDataSetChanged();
        }

        public ManeuverPair getItem(int position) {
            return maneuvers.get(position);
        }

        @Override
        public Object instantiateItem(ViewGroup container, int position) {
            View v = LayoutInflater.from(container.getContext())
                    .inflate(R.layout.item_maneuver, container, false);

            ImageView direction = (ImageView) v.findViewById(R.id.direction);
            TextView maneuver = (TextView) v.findViewById(R.id.maneuver);
            TextView nextManeuver = (TextView) v.findViewById(R.id.next_maneuver);
            ImageView nextDirection = (ImageView) v.findViewById(R.id.next_direction);

            final ManeuverPair m = maneuvers.get(position);
						// update the icon in the current maneuver page to represent the direction of the maneuver
            direction.setImageResource(displayHelper.getImageResourceForDirection(m.mainManeuver));
            maneuver.setText(displayHelper.stringForDirection(m.mainManeuver));

            if (m.turnManeuver == null) {
                nextManeuver.setVisibility(View.GONE);
                nextDirection.setVisibility(GONE);
                v.findViewById(R.id.next).setVisibility(GONE);
            } else {
                v.findViewById(R.id.next).setVisibility(VISIBLE);
                nextManeuver.setVisibility(View.VISIBLE);
                nextDirection.setVisibility(VISIBLE);
							  // update the icon in the current maneuver page to represent the directon of the maneuver
                nextDirection.setImageResource(displayHelper
                        .getImageResourceForDirection(m.turnManeuver));
                nextManeuver.setText(displayHelper.stringForDirection(m.turnManeuver));
            }

            if (position == maneuvers.size() - 1) {
						// final maneuver - customize directions to tell the user they are arriving at their destination
                v.findViewById(R.id.next).setVisibility(GONE);
                final int pointCount = navigator.getRoute().getPoints().size();
                PointOptions finalPoint = navigator.getRoute().getPoints().get(pointCount - 1);
                String customLocation = container.getContext().getString(R.string.custom_location_title);
                String arrive = container.getContext().getString(R.string.to_arrive,
                        finalPoint.getName() == null ? customLocation : finalPoint.getName());
                nextManeuver.setVisibility(View.VISIBLE);
                nextManeuver.setText(arrive);
            }

            container.addView(v);
            return v;
        }

        @Override
        public void destroyItem(ViewGroup container, int position, Object object) {
            container.removeView((View) object);
        }


        @Override
        public boolean isViewFromObject(View view, Object object) {
            return view.equals((View) object);
        }
    }
}

public static boolean isTalkbackOn(Context context) {
        AccessibilityManager am = (AccessibilityManager) context.getSystemService(Context.ACCESSIBILITY_SERVICE);
        boolean isAccessibilityEnabled = am.isEnabled();
        if (isAccessibilityEnabled) {
            List<AccessibilityServiceInfo> list = am.getEnabledAccessibilityServiceList(AccessibilityServiceInfo.FEEDBACK_AUDIBLE);
            if (list.size() > 0) {
                for (AccessibilityServiceInfo serviceInfo : list) {
                    if (serviceInfo.getId().contains("TalkBack")) {
                        return true;
                    }
                }
            }
        }
        return false;
    }