diff options
Diffstat (limited to 'platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity')
30 files changed, 4855 insertions, 0 deletions
diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/FeatureOverviewActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/FeatureOverviewActivity.java new file mode 100644 index 0000000000..9d514b2870 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/FeatureOverviewActivity.java @@ -0,0 +1,166 @@ +package com.mapbox.mapboxsdk.testapp.activity; + +import android.content.ComponentName; +import android.content.Intent; +import android.content.pm.ActivityInfo; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; + +import android.content.res.Resources; +import android.os.AsyncTask; +import android.os.Bundle; +import android.support.annotation.StringRes; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.LinearLayoutManager; +import android.support.v7.widget.RecyclerView; +import android.support.v7.widget.Toolbar; +import android.util.Log; +import android.view.View; + +import com.mapbox.mapboxsdk.constants.MapboxConstants; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.testapp.adapter.FeatureAdapter; +import com.mapbox.mapboxsdk.testapp.adapter.FeatureSectionAdapter; +import com.mapbox.mapboxsdk.testapp.model.activity.Feature; +import com.mapbox.mapboxsdk.testapp.utils.ItemClickSupport; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +public class FeatureOverviewActivity extends AppCompatActivity { + + private static final String KEY_STATE_FEATURES = "featureList"; + + private RecyclerView recyclerView; + private FeatureSectionAdapter sectionAdapter; + private List<Feature> features; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_main); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + toolbar.setTitle(getString(R.string.app_name)); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setElevation(getResources().getDimension(R.dimen.toolbar_shadow)); + } + + recyclerView = (RecyclerView) findViewById(R.id.recyclerView); + recyclerView.setLayoutManager(new LinearLayoutManager(this)); + recyclerView.addOnItemTouchListener(new RecyclerView.SimpleOnItemTouchListener()); + recyclerView.setHasFixedSize(true); + + ItemClickSupport.addTo(recyclerView).setOnItemClickListener(new ItemClickSupport.OnItemClickListener() { + @Override + public void onItemClicked(RecyclerView recyclerView, int position, View v) { + if (!sectionAdapter.isSectionHeaderPosition(position)) { + Intent intent = new Intent(); + int realPosition = sectionAdapter.getConvertedPosition(position); + intent.setComponent(new ComponentName(getPackageName(), features.get(realPosition).getName())); + startActivity(intent); + } + } + }); + + if (savedInstanceState == null) { + loadFeatures(); + } else { + features = savedInstanceState.getParcelableArrayList(KEY_STATE_FEATURES); + onFeaturesLoaded(features); + } + } + + private void loadFeatures() { + try { + new LoadFeatureTask().execute(getPackageManager().getPackageInfo(getPackageName(), PackageManager.GET_ACTIVITIES | PackageManager.GET_META_DATA)); + } catch (PackageManager.NameNotFoundException e) { + Log.e(MapboxConstants.TAG, "Could not resolve package info", e); + } + } + + private void onFeaturesLoaded(List<Feature> featuresList) { + features = featuresList; + + List<FeatureSectionAdapter.Section> sections = new ArrayList<>(); + String currentCat = ""; + for (int i = 0; i < features.size(); i++) { + String category = features.get(i).getCategory(); + if (!currentCat.equals(category)) { + sections.add(new FeatureSectionAdapter.Section(i, category)); + currentCat = category; + } + } + + FeatureSectionAdapter.Section[] dummy = new FeatureSectionAdapter.Section[sections.size()]; + sectionAdapter = new FeatureSectionAdapter(this, R.layout.section_main_layout, R.id.section_text, new FeatureAdapter(features)); + sectionAdapter.setSections(sections.toArray(dummy)); + recyclerView.setAdapter(sectionAdapter); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + outState.putParcelableArrayList(KEY_STATE_FEATURES, (ArrayList<Feature>) features); + } + + private class LoadFeatureTask extends AsyncTask<PackageInfo, Void, List<Feature>> { + + @Override + protected List<Feature> doInBackground(PackageInfo... params) { + List<Feature> features = new ArrayList<>(); + PackageInfo app = params[0]; + + String packageName = getApplicationContext().getPackageName(); + String metaDataKey = getString(R.string.category); + for (ActivityInfo info : app.activities) { + if (info.name.startsWith(packageName) && !info.name.equals(FeatureOverviewActivity.class.getName())) { + String label = getString(info.labelRes); + String description = resolveString(info.descriptionRes); + String category = resolveMetaData(info.metaData, metaDataKey); + features.add(new Feature(info.name, label, description, category)); + } + } + + if (!features.isEmpty()) { + Comparator<Feature> comparator = new Comparator<Feature>() { + @Override + public int compare(Feature lhs, Feature rhs) { + return lhs.getCategory().compareToIgnoreCase(rhs.getCategory()); + } + }; + Collections.sort(features, comparator); + } + + return features; + } + + private String resolveMetaData(Bundle bundle, String key) { + String category = null; + if (bundle != null) { + category = bundle.getString(key); + } + return category; + } + + private String resolveString(@StringRes int stringRes){ + try{ + return getString(stringRes); + }catch (Resources.NotFoundException e){ + return "-"; + } + } + + @Override + protected void onPostExecute(List<Feature> features) { + super.onPostExecute(features); + onFeaturesLoaded(features); + } + } +}
\ No newline at end of file diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/AnimatedMarkerActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/AnimatedMarkerActivity.java new file mode 100644 index 0000000000..1e15c9ea36 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/AnimatedMarkerActivity.java @@ -0,0 +1,125 @@ +package com.mapbox.mapboxsdk.testapp.activity.annotation; + +import android.animation.TypeEvaluator; +import android.animation.ValueAnimator; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.Menu; +import android.view.MenuItem; +import android.view.animation.AccelerateDecelerateInterpolator; + +import com.mapbox.mapboxsdk.annotations.Marker; +import com.mapbox.mapboxsdk.annotations.MarkerOptions; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; + +public class AnimatedMarkerActivity extends AppCompatActivity { + + private MapView mMapView; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_animated_marker); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mMapView = (MapView) findViewById(R.id.mapView); + mMapView.onCreate(savedInstanceState); + mMapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull final MapboxMap mapboxMap) { + LatLng brussels = new LatLng(50.900446, 4.485251); + LatLng washington = new LatLng(38.897108, -77.036716); + + final Marker marker = mapboxMap.addMarker(new MarkerOptions().position(brussels)); + ValueAnimator markerAnimator = ValueAnimator.ofObject(new LatLngEvaluator(), (Object[]) new LatLng[]{brussels, washington}); + markerAnimator.setDuration(5000); + markerAnimator.setRepeatCount(ValueAnimator.INFINITE); + markerAnimator.setRepeatMode(ValueAnimator.REVERSE); + markerAnimator.setInterpolator(new AccelerateDecelerateInterpolator()); + markerAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(ValueAnimator animation) { + if (marker != null) { + marker.setPosition((LatLng) animation.getAnimatedValue()); + } + } + }); + markerAnimator.start(); + } + }); + } + + @Override + public boolean onCreateOptionsMenu(Menu menu) { + getMenuInflater().inflate(R.menu.menu_zoom, menu); + return true; + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } + + @Override + public void onResume() { + super.onResume(); + mMapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mMapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mMapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mMapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mMapView.onLowMemory(); + } + + private class LatLngEvaluator implements TypeEvaluator<LatLng> { + + private LatLng mLatLng = new LatLng(); + + @Override + public LatLng evaluate(float fraction, LatLng startValue, LatLng endValue) { + mLatLng.setLatitude(startValue.getLatitude() + (endValue.getLatitude() - startValue.getLatitude()) * fraction); + mLatLng.setLongitude(startValue.getLongitude() + (endValue.getLongitude() - startValue.getLongitude()) * fraction); + return mLatLng; + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/BulkMarkerActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/BulkMarkerActivity.java new file mode 100644 index 0000000000..7a2241a84c --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/BulkMarkerActivity.java @@ -0,0 +1,307 @@ +package com.mapbox.mapboxsdk.testapp.activity.annotation; + +import android.animation.Animator; +import android.animation.AnimatorListenerAdapter; +import android.app.ProgressDialog; +import android.content.Context; +import android.os.AsyncTask; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.annotation.Nullable; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.MenuItem; +import android.view.View; +import android.view.ViewGroup; +import android.widget.AdapterView; +import android.widget.ArrayAdapter; +import android.widget.Spinner; +import android.widget.TextView; +import android.widget.Toast; + +import com.mapbox.mapboxsdk.annotations.Marker; +import com.mapbox.mapboxsdk.annotations.MarkerOptions; +import com.mapbox.mapboxsdk.annotations.MarkerView; +import com.mapbox.mapboxsdk.annotations.MarkerViewOptions; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.testapp.utils.GeoParseUtil; + +import org.json.JSONException; + +import java.io.IOException; +import java.text.DecimalFormat; +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +public class BulkMarkerActivity extends AppCompatActivity implements AdapterView.OnItemSelectedListener { + + private MapboxMap mMapboxMap; + private MapView mMapView; + private boolean mCustomMarkerView; + private List<LatLng> mLocations; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_marker_bulk); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + final ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayShowTitleEnabled(false); + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mMapView = (MapView) findViewById(R.id.mapView); + mMapView.onCreate(savedInstanceState); + mMapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull MapboxMap mapboxMap) { + mMapboxMap = mapboxMap; + + if (actionBar != null) { + ArrayAdapter<CharSequence> spinnerAdapter = ArrayAdapter.createFromResource(actionBar.getThemedContext(), R.array.bulk_marker_list, android.R.layout.simple_spinner_item); + spinnerAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + Spinner spinner = (Spinner) findViewById(R.id.spinner); + spinner.setAdapter(spinnerAdapter); + spinner.setOnItemSelectedListener(BulkMarkerActivity.this); + } + } + }); + + final View fab = findViewById(R.id.fab); + if (fab != null) { + fab.setOnClickListener(new FabClickListener()); + } + } + + public static class TextAdapter extends MapboxMap.MarkerViewAdapter<MarkerView> { + + private LayoutInflater inflater; + + public TextAdapter(@NonNull Context context) { + super(context); + this.inflater = LayoutInflater.from(context); + } + + @Nullable + @Override + public View getView(@NonNull MarkerView marker, @Nullable View convertView, @NonNull ViewGroup parent) { + ViewHolder viewHolder; + if (convertView == null) { + viewHolder = new ViewHolder(); + convertView = inflater.inflate(R.layout.view_text_marker, parent, false); + viewHolder.title = (TextView) convertView.findViewById(R.id.textView); + convertView.setTag(viewHolder); + } else { + viewHolder = (ViewHolder) convertView.getTag(); + } + viewHolder.title.setText(marker.getTitle()); + return convertView; + } + + private static class ViewHolder { + TextView title; + } + } + + @Override + public void onItemSelected(AdapterView<?> parent, View view, int position, long id) { + int amount = Integer.valueOf(getResources().getStringArray(R.array.bulk_marker_list)[position]); + if (mLocations == null) { + new LoadLocationTask(this, amount).execute(); + } else { + showMarkers(amount); + } + } + + + private void onLatLngListLoaded(List<LatLng> latLngs, int amount) { + mLocations = latLngs; + showMarkers(amount); + } + + private void showMarkers(int amount) { + mMapboxMap.clear(); + + if (mLocations.size() < amount) { + amount = mLocations.size(); + } + + if (mCustomMarkerView) { + showNativeMarkers(amount); + } else { + showGlMarkers(amount); + } + } + + private void showNativeMarkers(int amount) { + DecimalFormat formatter = new DecimalFormat("#.#####"); + Random random = new Random(); + int randomIndex; + + for (int i = 0; i < amount; i++) { + randomIndex = random.nextInt(mLocations.size()); + LatLng latLng = mLocations.get(randomIndex); + mMapboxMap.addMarker(new MarkerViewOptions() + .position(latLng) + .title(String.valueOf(i)) + .snippet(formatter.format(latLng.getLatitude()) + ", " + formatter.format(latLng.getLongitude()))); + } + } + + private void showGlMarkers(int amount) { + List<MarkerOptions> markerOptionsList = new ArrayList<>(); + DecimalFormat formatter = new DecimalFormat("#.#####"); + Random random = new Random(); + int randomIndex; + + for (int i = 0; i < amount; i++) { + randomIndex = random.nextInt(mLocations.size()); + LatLng latLng = mLocations.get(randomIndex); + markerOptionsList.add(new MarkerOptions() + .position(latLng) + .title(String.valueOf(i)) + .snippet(formatter.format(latLng.getLatitude()) + ", " + formatter.format(latLng.getLongitude()))); + } + + mMapboxMap.addMarkers(markerOptionsList); + } + + @Override + public void onNothingSelected(AdapterView<?> parent) { + // nothing selected, nothing to do! + } + + @Override + public void onResume() { + super.onResume(); + mMapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mMapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mMapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mMapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mMapView.onLowMemory(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } + + private class FabClickListener implements View.OnClickListener { + @Override + public void onClick(final View v) { + if (mMapboxMap != null) { + mCustomMarkerView = true; + + // remove fab + v.animate().alpha(0).setListener(new AnimatorListenerAdapter() { + @Override + public void onAnimationEnd(Animator animation) { + super.onAnimationEnd(animation); + v.setVisibility(View.GONE); + } + }).start(); + + // reload markers + Spinner spinner = (Spinner) findViewById(R.id.spinner); + if (spinner != null) { + int amount = Integer.valueOf(getResources().getStringArray(R.array.bulk_marker_list)[spinner.getSelectedItemPosition()]); + showMarkers(amount); + } + + // add adapter + mMapboxMap.getMarkerViewManager().addMarkerViewAdapter(new TextAdapter(BulkMarkerActivity.this)); + + mMapView.addOnMapChangedListener(new MapView.OnMapChangedListener() { + @Override + public void onMapChanged(@MapView.MapChange int change) { + if (change == MapView.REGION_IS_CHANGING || change == MapView.REGION_DID_CHANGE) { + if (!mMapboxMap.getMarkerViewManager().getMarkerViewAdapters().isEmpty()) { + TextView viewCountView = (TextView) findViewById(R.id.countView); + viewCountView.setText("ViewCache size " + (mMapView.getChildCount() - 5)); + } + } + } + }); + + mMapboxMap.getMarkerViewManager().setOnMarkerViewClickListener(new MapboxMap.OnMarkerViewClickListener() { + @Override + public boolean onMarkerClick(@NonNull Marker marker, @NonNull View view, @NonNull MapboxMap.MarkerViewAdapter adapter) { + Toast.makeText(BulkMarkerActivity.this, "Hello " + marker.getId(), Toast.LENGTH_SHORT).show(); + return false; + } + }); + } + } + } + + private static class LoadLocationTask extends AsyncTask<Void, Integer, List<LatLng>> { + + private static final String TAG = "LoadLocationTask"; + private BulkMarkerActivity mActivity; + private ProgressDialog mProgressDialog; + private int mAmount; + + public LoadLocationTask(BulkMarkerActivity activity, int amount) { + mAmount = amount; + mActivity = activity; + mProgressDialog = ProgressDialog.show(activity, "Loading", "Fetching markers", false); + } + + @Override + protected List<LatLng> doInBackground(Void... params) { + try { + String json = GeoParseUtil.loadStringFromAssets(mActivity.getApplicationContext(), "points.geojson"); + return GeoParseUtil.parseGeoJSONCoordinates(json); + } catch (IOException | JSONException e) { + Log.e(TAG, "Could not add markers,", e); + return null; + } + } + + @Override + protected void onPostExecute(List<LatLng> locations) { + super.onPostExecute(locations); + mActivity.onLatLngListLoaded(locations, mAmount); + mProgressDialog.hide(); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/DynamicMarkerChangeActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/DynamicMarkerChangeActivity.java new file mode 100644 index 0000000000..fcddf8ca54 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/DynamicMarkerChangeActivity.java @@ -0,0 +1,129 @@ +package com.mapbox.mapboxsdk.testapp.activity.annotation; + +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.design.widget.FloatingActionButton; +import android.support.v4.content.ContextCompat; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.MenuItem; +import android.view.View; + +import com.mapbox.mapboxsdk.annotations.IconFactory; +import com.mapbox.mapboxsdk.annotations.Marker; +import com.mapbox.mapboxsdk.annotations.MarkerOptions; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; + +public class DynamicMarkerChangeActivity extends AppCompatActivity { + + private static final LatLng LAT_LNG_CHELSEA = new LatLng(51.481670, -0.190849); + private static final LatLng LAT_LNG_ARSENAL = new LatLng(51.555062, -0.108417); + + private MapView mMapView; + private MapboxMap mMapboxMap; + private IconFactory mIconFactory; + private Marker mMarker; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_dynamic_marker); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mIconFactory = IconFactory.getInstance(this); + + mMapView = (MapView) findViewById(R.id.mapView); + mMapView.setTag(false); + mMapView.onCreate(savedInstanceState); + mMapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull MapboxMap mapboxMap) { + mMapboxMap = mapboxMap; + mapboxMap.moveCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(51.506675, -0.128699), 10)); + + // Create marker + MarkerOptions markerOptions = new MarkerOptions() + .position(LAT_LNG_CHELSEA) + .icon(mIconFactory.fromResource(R.drawable.ic_chelsea)); + mMarker = mapboxMap.addMarker(markerOptions); + } + }); + + + FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab); + fab.setColorFilter(ContextCompat.getColor(this, R.color.primary)); + fab.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + if (mMapboxMap != null) { + updateMarker(); + } + } + }); + } + + private void updateMarker() { + // update model + boolean first = (boolean) mMapView.getTag(); + mMapView.setTag(!first); + + // update marker + mMarker.setPosition(first ? LAT_LNG_CHELSEA : LAT_LNG_ARSENAL); + mMarker.setIcon(mIconFactory.fromResource(first ? R.drawable.ic_chelsea : R.drawable.ic_arsenal)); + } + + @Override + public void onResume() { + super.onResume(); + mMapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mMapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mMapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mMapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mMapView.onLowMemory(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/MarkerViewActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/MarkerViewActivity.java new file mode 100644 index 0000000000..65a5afa602 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/MarkerViewActivity.java @@ -0,0 +1,228 @@ +package com.mapbox.mapboxsdk.testapp.activity.annotation; + +import android.content.Context; +import android.graphics.Point; +import android.os.Bundle; +import android.os.Handler; +import android.support.annotation.NonNull; +import android.support.annotation.Nullable; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.LayoutInflater; +import android.view.MenuItem; +import android.view.View; +import android.view.ViewGroup; +import android.widget.ImageView; +import android.widget.TextView; +import android.widget.Toast; + +import com.mapbox.mapboxsdk.annotations.Marker; +import com.mapbox.mapboxsdk.annotations.MarkerView; +import com.mapbox.mapboxsdk.annotations.MarkerViewManager; +import com.mapbox.mapboxsdk.annotations.MarkerViewOptions; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.testapp.model.annotations.CountryMarkerOptions; +import com.mapbox.mapboxsdk.testapp.model.annotations.CountryMarkerView; +import com.mapbox.mapboxsdk.testapp.model.annotations.CountryMarkerViewOptions; + +public class MarkerViewActivity extends AppCompatActivity { + + private MapboxMap mMapboxMap; + private MapView mMapView; + + private final static LatLng[] LAT_LNGS = new LatLng[]{ + new LatLng(38.907327, -77.041293), + new LatLng(38.909698, -77.029642), + new LatLng(38.907227, -77.036530), + new LatLng(38.905607, -77.031916), + new LatLng(38.897424, -77.036508), + new LatLng(38.897642, -77.041980), + new LatLng(38.889876, -77.008849), + new LatLng(38.889441, -77.050134) + }; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_marker_view); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + final ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + final TextView viewCountView = (TextView) findViewById(R.id.countView); + mMapView = (MapView) findViewById(R.id.mapView); + mMapView.onCreate(savedInstanceState); + mMapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull MapboxMap mapboxMap) { + mMapboxMap = mapboxMap; + + // add text markers + for (int i = 0; i < LAT_LNGS.length; i++) { + mMapboxMap.addMarker(new MarkerViewOptions() + .position(LAT_LNGS[i]) + .title(String.valueOf(i)) + .selectAnimatorResource(R.animator.scale_up) + .deselectAnimatorResource(R.animator.scale_down) + ); + } + + // add flag marker + CountryMarkerViewOptions options = new CountryMarkerViewOptions(); + options.title("United States"); + options.abbrevName("us"); + options.flagRes(R.drawable.ic_us); + options.position(new LatLng(38.899774, -77.023237)); + options.selectAnimatorResource(R.animator.rotate_360); + options.deselectAnimatorResource(R.animator.rotate_360); + options.flat(true); + mapboxMap.addMarker(options); + + // default GL marker + mMapboxMap.addMarker(new CountryMarkerOptions() + .title("United States") + .position(new LatLng(38.902580, -77.050102)) + ); + + // set adapters + final MarkerViewManager markerViewManager = mapboxMap.getMarkerViewManager(); + markerViewManager.addMarkerViewAdapter(new TextAdapter(MarkerViewActivity.this)); + markerViewManager.addMarkerViewAdapter(new CountryAdapter(MarkerViewActivity.this)); + + mMapView.addOnMapChangedListener(new MapView.OnMapChangedListener() { + @Override + public void onMapChanged(@MapView.MapChange int change) { + if (change == MapView.REGION_IS_CHANGING || change == MapView.REGION_DID_CHANGE) { + if (!markerViewManager.getMarkerViewAdapters().isEmpty() && viewCountView != null) { + viewCountView.setText("ViewCache size " + (mMapView.getChildCount() - 5)); + } + } + } + }); + + mMapboxMap.getMarkerViewManager().setOnMarkerViewClickListener(new MapboxMap.OnMarkerViewClickListener() { + @Override + public boolean onMarkerClick(@NonNull Marker marker, @NonNull View view, @NonNull MapboxMap.MarkerViewAdapter adapter) { + Toast.makeText(MarkerViewActivity.this, "Hello " + marker.getId(), Toast.LENGTH_SHORT).show(); + return false; + } + }); + } + }); + } + + private static class TextAdapter extends MapboxMap.MarkerViewAdapter<MarkerView> { + + private LayoutInflater inflater; + + public TextAdapter(@NonNull Context context) { + super(context); + this.inflater = LayoutInflater.from(context); + } + + @Nullable + @Override + public View getView(@NonNull MarkerView marker, @Nullable View convertView, @NonNull ViewGroup parent) { + ViewHolder viewHolder; + if (convertView == null) { + viewHolder = new ViewHolder(); + convertView = inflater.inflate(R.layout.view_text_marker, parent, false); + viewHolder.title = (TextView) convertView.findViewById(R.id.textView); + convertView.setTag(viewHolder); + } else { + viewHolder = (ViewHolder) convertView.getTag(); + } + viewHolder.title.setText(marker.getTitle()); + return convertView; + } + + private static class ViewHolder { + TextView title; + } + } + + private static class CountryAdapter extends MapboxMap.MarkerViewAdapter<CountryMarkerView> { + + private LayoutInflater inflater; + + public CountryAdapter(@NonNull Context context) { + super(context); + this.inflater = LayoutInflater.from(context); + } + + @Nullable + @Override + public View getView(@NonNull CountryMarkerView marker, @Nullable View convertView, @NonNull ViewGroup parent) { + ViewHolder viewHolder; + if (convertView == null) { + viewHolder = new ViewHolder(); + convertView = inflater.inflate(R.layout.view_custom_marker, parent, false); + viewHolder.flag = (ImageView) convertView.findViewById(R.id.imageView); + viewHolder.abbrev = (TextView) convertView.findViewById(R.id.textView); + convertView.setTag(viewHolder); + } else { + viewHolder = (ViewHolder) convertView.getTag(); + } + viewHolder.flag.setImageResource(marker.getFlagRes()); + viewHolder.abbrev.setText(marker.getAbbrevName()); + return convertView; + } + + private static class ViewHolder { + ImageView flag; + TextView abbrev; + } + } + + @Override + public void onResume() { + super.onResume(); + mMapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mMapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mMapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mMapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mMapView.onLowMemory(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/PolygonActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/PolygonActivity.java new file mode 100644 index 0000000000..f08d65163b --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/PolygonActivity.java @@ -0,0 +1,124 @@ +package com.mapbox.mapboxsdk.testapp.activity.annotation; + +import android.graphics.Color; +import android.os.Bundle; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.MenuItem; +import android.view.ViewGroup; + +import com.mapbox.mapboxsdk.annotations.PolygonOptions; +import com.mapbox.mapboxsdk.camera.CameraPosition; +import com.mapbox.mapboxsdk.constants.Style; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.MapboxMapOptions; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.testapp.model.constants.AppConstant; + +import java.util.ArrayList; +import java.util.List; + +public class PolygonActivity extends AppCompatActivity { + + private MapView mapView; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_polygon); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + // configure inital map state + MapboxMapOptions options = new MapboxMapOptions() + .attributionTintColor(Color.RED) + .accessToken(getString(R.string.mapbox_access_token)) + .styleUrl(Style.getMapboxStreetsUrl(AppConstant.STYLE_VERSION)) + .camera(new CameraPosition.Builder() + .target(new LatLng(45.520486, -122.673541)) + .zoom(12) + .tilt(40) + .build()); + + // create map + mapView = new MapView(this, options); + mapView.onCreate(savedInstanceState); + mapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(MapboxMap mapboxMap) { + List<LatLng> polygon = new ArrayList<>(); + polygon.add(new LatLng(45.522585, -122.685699)); + polygon.add(new LatLng(45.534611, -122.708873)); + polygon.add(new LatLng(45.530883, -122.678833)); + polygon.add(new LatLng(45.547115, -122.667503)); + polygon.add(new LatLng(45.530643, -122.660121)); + polygon.add(new LatLng(45.533529, -122.636260)); + polygon.add(new LatLng(45.521743, -122.659091)); + polygon.add(new LatLng(45.510677, -122.648792)); + polygon.add(new LatLng(45.515008, -122.664070)); + polygon.add(new LatLng(45.502496, -122.669048)); + polygon.add(new LatLng(45.515369, -122.678489)); + polygon.add(new LatLng(45.506346, -122.702007)); + polygon.add(new LatLng(45.522585, -122.685699)); + mapboxMap.addPolygon(new PolygonOptions() + .addAll(polygon) + .fillColor(Color.parseColor("#3bb2d0"))); + } + }); + + // add to layout + ((ViewGroup) findViewById(R.id.container)).addView(mapView); + } + + @Override + public void onResume() { + super.onResume(); + mapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mapView.onLowMemory(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/PolylineActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/PolylineActivity.java new file mode 100644 index 0000000000..9eb4bc1741 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/PolylineActivity.java @@ -0,0 +1,172 @@ +package com.mapbox.mapboxsdk.testapp.activity.annotation; + +import android.graphics.Color; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; + +import com.mapbox.mapboxsdk.annotations.Polyline; +import com.mapbox.mapboxsdk.annotations.PolylineOptions; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class PolylineActivity extends AppCompatActivity { + + private static final String STATE_POLYLINE_OPTIONS = "polylineOptions"; + private static final LatLng ANDORRA = new LatLng(42.505777, 1.52529); + private static final LatLng LUXEMBOURG = new LatLng(49.815273, 6.129583); + private static final LatLng MONACO = new LatLng(43.738418, 7.424616); + private static final LatLng VATICAN_CITY = new LatLng(41.902916, 12.453389); + private static final LatLng SAN_MARINO = new LatLng(43.942360, 12.457777); + private static final LatLng LIECHTENSTEIN = new LatLng(47.166000, 9.555373); + + private List<Polyline> mPolylines; + private ArrayList<PolylineOptions> mPolylineOptions = new ArrayList<>(); + private MapView mMapView; + private MapboxMap mMapboxMap; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_polyline); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + if (savedInstanceState != null) { + mPolylineOptions = savedInstanceState.getParcelableArrayList(STATE_POLYLINE_OPTIONS); + } else { + mPolylineOptions.addAll(getAllPolylines()); + } + + mMapView = (MapView) findViewById(R.id.mapView); + mMapView.onCreate(savedInstanceState); + mMapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull MapboxMap mapboxMap) { + mMapboxMap = mapboxMap; + mPolylines = mapboxMap.addPolylines(mPolylineOptions); + } + }); + + findViewById(R.id.fab).setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + if (mMapboxMap != null) { + if (mPolylines != null && mPolylines.size() > 0) { + if (mPolylines.size() == 1) { + // test for removing annotation + mMapboxMap.removeAnnotation(mPolylines.get(0)); + } else { + // test for removing annotations + mMapboxMap.removeAnnotations(mPolylines); + } + } + mPolylineOptions.clear(); + mPolylineOptions.addAll(getRandomLine()); + mPolylines = mMapboxMap.addPolylines(mPolylineOptions); + } + } + }); + } + + private List<PolylineOptions> getAllPolylines() { + List<PolylineOptions> options = new ArrayList<>(); + options.add(generatePolyline(ANDORRA, LUXEMBOURG, "#F44336")); + options.add(generatePolyline(ANDORRA, MONACO, "#FF5722")); + options.add(generatePolyline(MONACO, VATICAN_CITY, "#673AB7")); + options.add(generatePolyline(VATICAN_CITY, SAN_MARINO, "#009688")); + options.add(generatePolyline(SAN_MARINO, LIECHTENSTEIN, "#795548")); + options.add(generatePolyline(LIECHTENSTEIN, LUXEMBOURG, "#3F51B5")); + return options; + } + + private PolylineOptions generatePolyline(LatLng start, LatLng end, String color) { + PolylineOptions line = new PolylineOptions(); + line.add(start); + line.add(end); + line.color(Color.parseColor(color)); + return line; + } + + public List<PolylineOptions> getRandomLine() { + final List<PolylineOptions> randomLines = getAllPolylines(); + Collections.shuffle(randomLines); + return new ArrayList<PolylineOptions>() {{ + add(randomLines.get(0)); + }}; + } + + @Override + public void onResume() { + super.onResume(); + mMapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mMapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mMapView.onSaveInstanceState(outState); + outState.putParcelableArrayList(STATE_POLYLINE_OPTIONS, mPolylineOptions); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mMapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mMapView.onLowMemory(); + } + + @Override + public boolean onCreateOptionsMenu(Menu menu) { + getMenuInflater().inflate(R.menu.menu_polyline, menu); + return super.onCreateOptionsMenu(menu); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case R.id.action_id_remove: + // test to remove all annotations + mPolylineOptions.clear(); + mMapboxMap.clear(); + return true; + + case android.R.id.home: + onBackPressed(); + return true; + + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/PressForMarkerActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/PressForMarkerActivity.java new file mode 100644 index 0000000000..88008d64fb --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/annotation/PressForMarkerActivity.java @@ -0,0 +1,141 @@ +package com.mapbox.mapboxsdk.testapp.activity.annotation; + +import android.graphics.PointF; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.annotation.Nullable; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.Menu; +import android.view.MenuItem; +import com.mapbox.mapboxsdk.annotations.MarkerOptions; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.constants.Style; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; +import java.text.DecimalFormat; +import java.util.ArrayList; + +public class PressForMarkerActivity extends AppCompatActivity { + + private MapView mapView; + private MapboxMap mapboxMap; + private ArrayList<MarkerOptions> mMarkerList = new ArrayList<>(); + + private static final DecimalFormat LAT_LON_FORMATTER = new DecimalFormat("#.#####"); + + private static String STATE_MARKER_LIST = "markerList"; + + @Override + protected void onCreate(@Nullable final Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_press_for_marker); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mapView = (MapView) findViewById(R.id.pressForMarkerMapView); + mapView.onCreate(savedInstanceState); + mapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(final MapboxMap map) { + mapboxMap = map; + mapboxMap.setStyleUrl(Style.getOutdoorsStyleUrl(9)); + resetMap(); + + mapboxMap.setOnMapLongClickListener(new MapboxMap.OnMapLongClickListener() { + @Override + public void onMapLongClick(@NonNull LatLng point) { + final PointF pixel = mapboxMap.getProjection().toScreenLocation(point); + + String title = LAT_LON_FORMATTER.format(point.getLatitude()) + ", " + LAT_LON_FORMATTER.format(point.getLongitude()); + String snippet = "X = " + (int) pixel.x + ", Y = " + (int) pixel.y; + + MarkerOptions marker = new MarkerOptions() + .position(point) + .title(title) + .snippet(snippet); + + mMarkerList.add(marker); + mapboxMap.addMarker(marker); + } + }); + + if (savedInstanceState != null) { + mMarkerList = savedInstanceState.getParcelableArrayList(STATE_MARKER_LIST); + mapboxMap.addMarkers(mMarkerList); + } + } + }); + } + + private void resetMap() { + if (mapboxMap == null) { + return; + } + mapboxMap.moveCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(45.1855569, 5.7215506), 11)); + mapboxMap.removeAnnotations(); + } + + @Override + public boolean onCreateOptionsMenu(Menu menu) { + getMenuInflater().inflate(R.menu.menu_press_for_marker, menu); + return true; + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + + mapView.onSaveInstanceState(outState); + outState.putParcelableArrayList(STATE_MARKER_LIST, mMarkerList); + } + + @Override + public void onResume() { + super.onResume(); + mapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mapView.onPause(); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mapView.onLowMemory(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + case R.id.menuItemReset: + resetMap(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/CameraAnimationTypeActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/CameraAnimationTypeActivity.java new file mode 100644 index 0000000000..44758cd146 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/CameraAnimationTypeActivity.java @@ -0,0 +1,180 @@ +package com.mapbox.mapboxsdk.testapp.activity.camera; + +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.util.Log; +import android.view.MenuItem; +import android.view.View; +import android.widget.Toast; + +import com.mapbox.mapboxsdk.constants.MapboxConstants; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.camera.CameraPosition; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.maps.MapView; + +public class CameraAnimationTypeActivity extends AppCompatActivity { + + private static final String TAG = "CameraActivity"; + + private MapView mapView; + + private boolean cameraState; + private static final LatLng LAT_LNG_LONDON_EYE = new LatLng(51.50325, -0.11968); + private static final LatLng LAT_LNG_TOWER_BRIDGE = new LatLng(51.50550, -0.07520); + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_camera_animation_types); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mapView = (MapView) findViewById(R.id.mapView); + mapView.onCreate(savedInstanceState); + mapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull final MapboxMap mapboxMap) { + mapboxMap.getUiSettings().setAttributionEnabled(false); + mapboxMap.getUiSettings().setLogoEnabled(false); + mapboxMap.setOnCameraChangeListener(new MapboxMap.OnCameraChangeListener() { + @Override + public void onCameraChange(CameraPosition position) { + Log.v(MapboxConstants.TAG, position.toString()); + } + }); + + // handle move button clicks + findViewById(R.id.cameraMoveButton).setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + CameraPosition cameraPosition = new CameraPosition.Builder() + .target(getNextLatLng()) + .zoom(14) + .tilt(30) + .tilt(0) + .build(); + + mapboxMap.moveCamera(CameraUpdateFactory.newCameraPosition(cameraPosition)); + } + }); + + // handle ease button clicks + findViewById(R.id.cameraEaseButton).setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + CameraPosition cameraPosition = new CameraPosition.Builder() + .target(getNextLatLng()) + .zoom(15) + .bearing(180) + .tilt(30) + .build(); + + MapboxMap.CancelableCallback callback = new MapboxMap.CancelableCallback() { + @Override + public void onCancel() { + Log.i(TAG, "Duration onCancel Callback called."); + Toast.makeText(CameraAnimationTypeActivity.this, "Ease onCancel Callback called.", Toast.LENGTH_LONG).show(); + } + + @Override + public void onFinish() { + Log.i(TAG, "Duration onFinish Callback called."); + Toast.makeText(CameraAnimationTypeActivity.this, "Ease onFinish Callback called.", Toast.LENGTH_LONG).show(); + } + }; + + mapboxMap.easeCamera(CameraUpdateFactory.newCameraPosition(cameraPosition), 7500, callback); + } + }); + + // handle animate button clicks + findViewById(R.id.cameraAnimateButton).setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + CameraPosition cameraPosition = new CameraPosition.Builder() + .target(getNextLatLng()) + .bearing(270) + .tilt(20) + .build(); + + MapboxMap.CancelableCallback callback = new MapboxMap.CancelableCallback() { + @Override + public void onCancel() { + Log.i(TAG, "Duration onCancel Callback called."); + Toast.makeText(CameraAnimationTypeActivity.this, "Duration onCancel Callback called.", Toast.LENGTH_LONG).show(); + } + + @Override + public void onFinish() { + Log.i(TAG, "Duration onFinish Callback called."); + Toast.makeText(CameraAnimationTypeActivity.this, "Duration onFinish Callback called.", Toast.LENGTH_LONG).show(); + } + }; + + mapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition), 7500, callback); + } + }); + } + }); + } + + private LatLng getNextLatLng() { + cameraState = !cameraState; + return cameraState ? LAT_LNG_TOWER_BRIDGE : LAT_LNG_LONDON_EYE; + } + + @Override + public void onResume() { + super.onResume(); + mapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mapView.onLowMemory(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/CameraPositionActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/CameraPositionActivity.java new file mode 100644 index 0000000000..220bef197b --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/CameraPositionActivity.java @@ -0,0 +1,176 @@ +package com.mapbox.mapboxsdk.testapp.activity.camera; + +import android.content.Context; +import android.content.DialogInterface; +import android.os.Bundle; +import android.support.annotation.IdRes; +import android.support.annotation.NonNull; +import android.support.design.widget.FloatingActionButton; +import android.support.v4.content.ContextCompat; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AlertDialog; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.MenuItem; +import android.view.View; +import android.widget.SeekBar; +import android.widget.TextView; + +import com.mapbox.mapboxsdk.camera.CameraPosition; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.constants.MapboxConstants; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; + +public class CameraPositionActivity extends AppCompatActivity implements OnMapReadyCallback { + + private MapView mapView; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_camera_position); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mapView = (MapView) findViewById(R.id.mapView); + mapView.onCreate(savedInstanceState); + mapView.getMapAsync(this); + } + + @Override + public void onMapReady(@NonNull final MapboxMap mapboxMap) { + // add a listener to FAB + FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab); + fab.setColorFilter(ContextCompat.getColor(CameraPositionActivity.this, R.color.primary)); + fab.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + Context context = v.getContext(); + final View dialogContent = LayoutInflater.from(context).inflate(R.layout.dialog_camera_position, null); + AlertDialog.Builder builder = new AlertDialog.Builder(context, com.mapbox.mapboxsdk.R.style.AttributionAlertDialogStyle); + builder.setTitle(R.string.dialog_camera_position); + builder.setView(onInflateDialogContent(dialogContent)); + builder.setPositiveButton("Animate", new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, int which) { + double latitude = Double.parseDouble(((TextView) dialogContent.findViewById(R.id.value_lat)).getText().toString()); + double longitude = Double.parseDouble(((TextView) dialogContent.findViewById(R.id.value_lon)).getText().toString()); + double zoom = Double.parseDouble(((TextView) dialogContent.findViewById(R.id.value_zoom)).getText().toString()); + double bearing = Double.parseDouble(((TextView) dialogContent.findViewById(R.id.value_bearing)).getText().toString()); + double tilt = Double.parseDouble(((TextView) dialogContent.findViewById(R.id.value_tilt)).getText().toString()); + + CameraPosition cameraPosition = new CameraPosition.Builder() + .target(new LatLng(latitude, longitude)) + .zoom(zoom) + .bearing(bearing) + .tilt(tilt) + .build(); + + mapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition), 5000); + Log.v(MapboxConstants.TAG, cameraPosition.toString()); + } + }); + builder.setNegativeButton("Cancel", null); + builder.setCancelable(false); + builder.show(); + } + }); + } + + @Override + public void onPause() { + super.onPause(); + mapView.onPause(); + } + + @Override + public void onResume() { + super.onResume(); + mapView.onResume(); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mapView.onDestroy(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mapView.onSaveInstanceState(outState); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } + + private View onInflateDialogContent(View view) { + linkTextView(view, R.id.value_lat, R.id.seekbar_lat, new LatLngChangeListener(), 180 + 38); + linkTextView(view, R.id.value_lon, R.id.seekbar_lon, new LatLngChangeListener(), 180 - 77); + linkTextView(view, R.id.value_zoom, R.id.seekbar_zoom, new ValueChangeListener(), 6); + linkTextView(view, R.id.value_bearing, R.id.seekbar_bearing, new ValueChangeListener(), 90); + linkTextView(view, R.id.value_tilt, R.id.seekbar_tilt, new ValueChangeListener(), 40); + return view; + } + + private void linkTextView(View view, @IdRes int textViewRes, @IdRes int seekBarRes, ValueChangeListener listener, int defaultValue) { + final TextView value = (TextView) view.findViewById(textViewRes); + SeekBar seekBar = (SeekBar) view.findViewById(seekBarRes); + listener.setLinkedValueView(value); + seekBar.setOnSeekBarChangeListener(listener); + seekBar.setProgress(defaultValue); + } + + private class ValueChangeListener implements SeekBar.OnSeekBarChangeListener { + + protected TextView textView; + + public void setLinkedValueView(TextView textView) { + this.textView = textView; + } + + @Override + public void onStartTrackingTouch(SeekBar seekBar) { + + } + + @Override + public void onStopTrackingTouch(SeekBar seekBar) { + + } + + @Override + public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) { + textView.setText(String.valueOf(progress)); + } + } + + private class LatLngChangeListener extends ValueChangeListener { + + @Override + public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) { + super.onProgressChanged(seekBar, progress - 180, fromUser); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/LatLngBoundsActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/LatLngBoundsActivity.java new file mode 100644 index 0000000000..b9a438b7d5 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/LatLngBoundsActivity.java @@ -0,0 +1,125 @@ +package com.mapbox.mapboxsdk.testapp.activity.camera; + +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.util.Log; +import android.view.MenuItem; + +import com.mapbox.mapboxsdk.annotations.MarkerOptions; +import com.mapbox.mapboxsdk.constants.MapboxConstants; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.constants.Style; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.geometry.LatLngBounds; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.maps.UiSettings; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.testapp.model.constants.AppConstant; + +public class LatLngBoundsActivity extends AppCompatActivity { + + private static final LatLng LOS_ANGELES = new LatLng(34.053940, -118.242622); + private static final LatLng NEW_YORK = new LatLng(40.712730, -74.005953); + + private MapView mMapView; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_visible_bounds); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mMapView = (MapView) findViewById(R.id.mapView); + mMapView.setStyleUrl(Style.getDarkStyleUrl(AppConstant.STYLE_VERSION)); + mMapView.onCreate(savedInstanceState); + mMapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull final MapboxMap mapboxMap) { + + UiSettings uiSettings = mapboxMap.getUiSettings(); + uiSettings.setAllGesturesEnabled(false); + + mapboxMap.addMarker(new MarkerOptions() + .title("Los Angeles") + .snippet("City Hall") + .position(LOS_ANGELES)); + + mapboxMap.addMarker(new MarkerOptions() + .title("New York") + .snippet("City Hall") + .position(NEW_YORK)); + + // Create Bounds + final LatLngBounds bounds = new LatLngBounds.Builder() + .include(NEW_YORK) + .include(LOS_ANGELES) + .build(); + + // Add map padding + int mapPadding = (int) getResources().getDimension(R.dimen.fab_margin); + mapboxMap.setPadding(mapPadding, mapPadding, mapPadding, mapPadding); + + // Move camera to the bounds with added padding + int padding = (int) getResources().getDimension(R.dimen.coordinatebounds_margin); + mapboxMap.animateCamera(CameraUpdateFactory.newLatLngBounds(bounds, padding)); + + // Call mapboxMap.getProjection().getVisibleRegion().latLngBounds to retrieve the bounds + Log.v(MapboxConstants.TAG, mapboxMap.getProjection().getVisibleRegion().latLngBounds.toString()); + } + }); + } + + @Override + public void onResume() { + super.onResume(); + mMapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mMapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mMapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mMapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mMapView.onLowMemory(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/ManualZoomActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/ManualZoomActivity.java new file mode 100644 index 0000000000..bc3691a2f7 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/ManualZoomActivity.java @@ -0,0 +1,124 @@ +package com.mapbox.mapboxsdk.testapp.activity.camera; + +import android.graphics.Point; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; + +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.constants.Style; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.maps.UiSettings; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.testapp.model.constants.AppConstant; + +public class ManualZoomActivity extends AppCompatActivity { + + private MapboxMap mMapboxMap; + private MapView mMapView; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_manual_zoom); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mMapView = (MapView) findViewById(R.id.manualZoomMapView); + mMapView.setStyleUrl(Style.getSatelliteStyleUrl(AppConstant.STYLE_VERSION)); + mMapView.onCreate(savedInstanceState); + mMapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull final MapboxMap mapboxMap) { + mMapboxMap = mapboxMap; + + UiSettings uiSettings = mMapboxMap.getUiSettings(); + uiSettings.setAllGesturesEnabled(false); + } + }); + } + + @Override + public boolean onCreateOptionsMenu(Menu menu) { +// findViewById(R.id.) + getMenuInflater().inflate(R.menu.menu_zoom, menu); + return true; + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + + case android.R.id.home: + onBackPressed(); + return true; + + case R.id.action_zoom_in: + mMapboxMap.animateCamera(CameraUpdateFactory.zoomIn()); + return true; + + case R.id.action_zoom_out: + mMapboxMap.animateCamera(CameraUpdateFactory.zoomOut()); + return true; + + case R.id.action_zoom_by: + mMapboxMap.animateCamera(CameraUpdateFactory.zoomBy(2)); + return true; + case R.id.action_zoom_to: + mMapboxMap.animateCamera(CameraUpdateFactory.zoomTo(2)); + return true; + + case R.id.action_zoom_to_point: + View view = getWindow().getDecorView(); + mMapboxMap.animateCamera(CameraUpdateFactory.zoomBy(1, new Point(view.getMeasuredWidth() / 4, view.getMeasuredHeight() / 4))); + return true; + + default: + return super.onOptionsItemSelected(item); + } + } + + @Override + public void onResume() { + super.onResume(); + mMapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mMapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mMapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mMapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mMapView.onLowMemory(); + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/MaxMinZoomActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/MaxMinZoomActivity.java new file mode 100644 index 0000000000..e9a9647d45 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/MaxMinZoomActivity.java @@ -0,0 +1,85 @@ +package com.mapbox.mapboxsdk.testapp.activity.camera; + +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.MenuItem; + +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.maps.UiSettings; +import com.mapbox.mapboxsdk.testapp.R; + +public class MaxMinZoomActivity extends AppCompatActivity { + + private MapView mMapView; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_maxmin_zoom); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mMapView = (MapView) findViewById(R.id.mapView); + mMapView.onCreate(savedInstanceState); + mMapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull final MapboxMap mapboxMap) { + mapboxMap.setMinZoom(3); + mapboxMap.setMaxZoom(5); + } + }); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + } + return false; + } + + @Override + public void onResume() { + super.onResume(); + mMapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mMapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mMapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mMapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mMapView.onLowMemory(); + } + +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/ScrollByActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/ScrollByActivity.java new file mode 100644 index 0000000000..729a08758e --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/camera/ScrollByActivity.java @@ -0,0 +1,146 @@ +package com.mapbox.mapboxsdk.testapp.activity.camera; + +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.annotation.StringRes; +import android.support.design.widget.FloatingActionButton; +import android.support.v4.content.ContextCompat; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.MenuItem; +import android.view.View; +import android.widget.SeekBar; +import android.widget.TextView; + +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.maps.UiSettings; +import com.mapbox.mapboxsdk.testapp.R; + +public class ScrollByActivity extends AppCompatActivity { + + public static final int MULTIPLIER_PER_PIXEL = 50; + + private MapView mMapView; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_scroll_by); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + final SeekBar xBar = (SeekBar) findViewById(R.id.seekbar_move_x); + TextView xText = (TextView) findViewById(R.id.textview_x); + xBar.setOnSeekBarChangeListener(new PixelBarChangeListener(xText, R.string.scrollby_x_value)); + + final SeekBar yBar = (SeekBar) findViewById(R.id.seekbar_move_y); + TextView yText = (TextView) findViewById(R.id.textview_y); + yBar.setOnSeekBarChangeListener(new PixelBarChangeListener(yText, R.string.scrollby_y_value)); + + mMapView = (MapView) findViewById(R.id.mapView); + mMapView.setTag(true); + mMapView.onCreate(savedInstanceState); + mMapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull final MapboxMap mapboxMap) { + UiSettings uiSettings = mapboxMap.getUiSettings(); + uiSettings.setLogoEnabled(false); + uiSettings.setAttributionEnabled(false); + + FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab); + fab.setColorFilter(ContextCompat.getColor(ScrollByActivity.this, R.color.primary)); + fab.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + mapboxMap.easeCamera(CameraUpdateFactory.scrollBy( + xBar.getProgress() * MULTIPLIER_PER_PIXEL, + yBar.getProgress() * MULTIPLIER_PER_PIXEL) + ); + } + }); + } + }); + } + + @Override + public void onResume() { + super.onResume(); + mMapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mMapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mMapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mMapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mMapView.onLowMemory(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } + + private static class PixelBarChangeListener implements SeekBar.OnSeekBarChangeListener { + + @StringRes + private int mPrefixTextResource; + private TextView mValueView; + + public PixelBarChangeListener(@NonNull TextView textView, @StringRes int textRes) { + mValueView = textView; + mPrefixTextResource = textRes; + } + + @Override + public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) { + int value = progress * ScrollByActivity.MULTIPLIER_PER_PIXEL; + mValueView.setText(String.format(seekBar.getResources().getString(mPrefixTextResource), value)); + } + + @Override + public void onStartTrackingTouch(SeekBar seekBar) { + + } + + @Override + public void onStopTrackingTouch(SeekBar seekBar) { + + } + } + + +}
\ No newline at end of file diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/customlayer/CustomLayerActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/customlayer/CustomLayerActivity.java new file mode 100644 index 0000000000..98c86d4313 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/customlayer/CustomLayerActivity.java @@ -0,0 +1,123 @@ +package com.mapbox.mapboxsdk.testapp.activity.customlayer; + +import android.os.Bundle; +import android.support.design.widget.FloatingActionButton; +import android.support.v4.content.ContextCompat; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.MenuItem; +import android.view.View; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.layers.CustomLayer; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.testapp.model.customlayer.ExampleCustomLayer; + +public class CustomLayerActivity extends AppCompatActivity { + + private MapboxMap mapboxMap; + private MapView mapView; + + private boolean isShowingCustomLayer = false; + private FloatingActionButton fab; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_custom_layer); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + final ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mapView = (MapView) findViewById(R.id.mapView); + mapView.onCreate(savedInstanceState); + mapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(MapboxMap map) { + mapboxMap = map; + + mapboxMap.moveCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(39.91448, -243.60947), 10)); + + } + }); + + fab = (FloatingActionButton) findViewById(R.id.fab); + fab.setColorFilter(ContextCompat.getColor(this, R.color.primary)); + fab.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + if (mapboxMap != null) { + swapCustomLayer(); + } + } + }); + } + + private void swapCustomLayer() { + + if (isShowingCustomLayer) { + mapboxMap.removeCustomLayer("custom"); + fab.setImageResource(R.drawable.ic_layers_24dp); + } else { + mapboxMap.addCustomLayer(new CustomLayer("custom", + ExampleCustomLayer.createContext(), + ExampleCustomLayer.InitializeFunction, + ExampleCustomLayer.RenderFunction, + ExampleCustomLayer.DeinitializeFunction), null); + fab.setImageResource(R.drawable.ic_layers_clear_24dp); + } + + isShowingCustomLayer = !isShowingCustomLayer; + } + + @Override + public void onResume() { + super.onResume(); + mapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mapView.onLowMemory(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/directions/DirectionsActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/directions/DirectionsActivity.java new file mode 100644 index 0000000000..d5f248f89d --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/directions/DirectionsActivity.java @@ -0,0 +1,183 @@ +package com.mapbox.mapboxsdk.testapp.activity.directions; + +import android.graphics.Color; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.util.Log; +import android.view.MenuItem; + +import com.mapbox.directions.DirectionsCriteria; +import com.mapbox.directions.MapboxDirections; +import com.mapbox.directions.service.models.DirectionsResponse; +import com.mapbox.directions.service.models.DirectionsRoute; +import com.mapbox.directions.service.models.Waypoint; +import com.mapbox.mapboxsdk.annotations.MarkerOptions; +import com.mapbox.mapboxsdk.annotations.PolylineOptions; +import com.mapbox.mapboxsdk.camera.CameraPosition; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.maps.MapView; + +import java.util.List; + +import retrofit.Callback; +import retrofit.Response; +import retrofit.Retrofit; + +public class DirectionsActivity extends AppCompatActivity { + + private final static String LOG_TAG = "DirectionsActivity"; + + private MapView mMapView; + private MapboxMap mMapboxMap; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_directions); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mMapView = (MapView) findViewById(R.id.mapView); + mMapView.onCreate(savedInstanceState); + mMapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull MapboxMap mapboxMap) { + mMapboxMap = mapboxMap; + loadRoute(); + } + }); + } + + private void loadRoute() { + // Dupont Circle (Washington, DC) + Waypoint origin = new Waypoint(-77.04341, 38.90962); + + // The White House (Washington, DC) + Waypoint destination = new Waypoint(-77.0365, 38.8977); + + // Set map at centroid + LatLng centroid = new LatLng( + (origin.getLatitude() + destination.getLatitude()) / 2, + (origin.getLongitude() + destination.getLongitude()) / 2); + + mMapboxMap.moveCamera(CameraUpdateFactory.newCameraPosition(new CameraPosition.Builder() + .target(centroid) + .zoom(14) + .build())); + + // Add origin and destination to the map + mMapboxMap.addMarker(new MarkerOptions() + .position(new LatLng(origin.getLatitude(), origin.getLongitude())) + .title("Origin") + .snippet("Dupont Circle")); + mMapboxMap.addMarker(new MarkerOptions() + .position(new LatLng(destination.getLatitude(), destination.getLongitude())) + .title("Destination") + .snippet("The White House")); + + // Get route from API + getRoute(origin, destination); + } + + private void getRoute(Waypoint origin, Waypoint destination) { + MapboxDirections md = new MapboxDirections.Builder() + .setAccessToken(getString(R.string.mapbox_access_token)) + .setOrigin(origin) + .setDestination(destination) + .setProfile(DirectionsCriteria.PROFILE_WALKING) + .build(); + + md.enqueue(new Callback<DirectionsResponse>() { + @Override + public void onResponse(Response<DirectionsResponse> response, Retrofit retrofit) { + // You can get generic HTTP info about the response + Log.d(LOG_TAG, "Response code: " + response.code()); + + // Print some info about the route + DirectionsRoute currentRoute = response.body().getRoutes().get(0); + Log.d(LOG_TAG, "Distance: " + currentRoute.getDistance()); + + // Draw the route on the map + drawRoute(currentRoute); + } + + @Override + public void onFailure(Throwable t) { + Log.e(LOG_TAG, "Error: " + t.getMessage()); + } + }); + } + + private void drawRoute(DirectionsRoute route) { + // Convert List<Waypoint> into LatLng[] + List<Waypoint> waypoints = route.getGeometry().getWaypoints(); + LatLng[] point = new LatLng[waypoints.size()]; + for (int i = 0; i < waypoints.size(); i++) { + point[i] = new LatLng( + waypoints.get(i).getLatitude(), + waypoints.get(i).getLongitude()); + } + + // Draw Points on MapView + mMapboxMap.addPolyline(new PolylineOptions() + .add(point) + .color(Color.parseColor("#3887be")) + .width(5)); + } + + @Override + public void onResume() { + super.onResume(); + mMapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mMapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mMapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mMapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mMapView.onLowMemory(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } + +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/fragment/MapFragmentActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/fragment/MapFragmentActivity.java new file mode 100644 index 0000000000..5987855aac --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/fragment/MapFragmentActivity.java @@ -0,0 +1,90 @@ +package com.mapbox.mapboxsdk.testapp.activity.fragment; + +import android.app.FragmentTransaction; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.MenuItem; + +import com.mapbox.mapboxsdk.camera.CameraPosition; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.constants.Style; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.MapFragment; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.MapboxMapOptions; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.testapp.model.constants.AppConstant; + +public class MapFragmentActivity extends AppCompatActivity { + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_map_fragment); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + MapFragment mapFragment; + if (savedInstanceState == null) { + FragmentTransaction transaction = getFragmentManager().beginTransaction(); + + MapboxMapOptions options = new MapboxMapOptions(); + options.styleUrl(Style.getOutdoorsStyleUrl(AppConstant.STYLE_VERSION)); + + options.scrollGesturesEnabled(false); + options.zoomGesturesEnabled(false); + options.tiltGesturesEnabled(false); + options.rotateGesturesEnabled(false); + + options.debugActive(false); +// options.compassEnabled(false); +// options.attributionEnabled(false); +// options.logoEnabled(false); + + LatLng dc = new LatLng(38.90252, -77.02291); + + options.minZoom(9); + options.maxZoom(11); + options.camera(new CameraPosition.Builder() + .target(dc) + .zoom(11) + .build()); + + mapFragment = MapFragment.newInstance(options); + + transaction.add(R.id.fragment_container, mapFragment, "com.mapbox.map"); + transaction.commit(); + } else { + mapFragment = (MapFragment) getFragmentManager().findFragmentByTag("com.mapbox.map"); + } + + mapFragment.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull MapboxMap mapboxMap) { + mapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(new CameraPosition.Builder().tilt(45.0).build()), 10000); + } + }); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/fragment/SupportMapFragmentActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/fragment/SupportMapFragmentActivity.java new file mode 100644 index 0000000000..bb391fc93d --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/fragment/SupportMapFragmentActivity.java @@ -0,0 +1,90 @@ +package com.mapbox.mapboxsdk.testapp.activity.fragment; + +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v4.app.FragmentTransaction; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.MenuItem; + +import com.mapbox.mapboxsdk.camera.CameraPosition; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.constants.Style; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.MapboxMapOptions; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.maps.SupportMapFragment; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.testapp.model.constants.AppConstant; + +public class SupportMapFragmentActivity extends AppCompatActivity { + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_map_fragment); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + SupportMapFragment mapFragment; + if (savedInstanceState == null) { + FragmentTransaction transaction = getSupportFragmentManager().beginTransaction(); + + MapboxMapOptions options = new MapboxMapOptions(); + options.styleUrl(Style.getSatelliteStreetsStyleUrl(AppConstant.STYLE_VERSION)); + + options.scrollGesturesEnabled(false); + options.zoomGesturesEnabled(false); + options.tiltGesturesEnabled(false); + options.rotateGesturesEnabled(false); + + options.debugActive(false); + options.compassEnabled(false); + options.attributionEnabled(false); + options.logoEnabled(false); + + LatLng dc = new LatLng(38.90252, -77.02291); + + options.minZoom(9); + options.maxZoom(11); + options.camera(new CameraPosition.Builder() + .target(dc) + .zoom(11) + .build()); + + mapFragment = SupportMapFragment.newInstance(options); + + transaction.add(R.id.fragment_container, mapFragment, "com.mapbox.map"); + transaction.commit(); + } else { + mapFragment = (SupportMapFragment) getSupportFragmentManager().findFragmentByTag("com.mapbox.map"); + } + + mapFragment.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull MapboxMap mapboxMap) { + mapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(new CameraPosition.Builder().tilt(45.0).build()), 10000); + } + }); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/geocoding/GeocoderActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/geocoding/GeocoderActivity.java new file mode 100644 index 0000000000..fc03066a4e --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/geocoding/GeocoderActivity.java @@ -0,0 +1,192 @@ +package com.mapbox.mapboxsdk.testapp.activity.geocoding; + +import android.graphics.PointF; +import android.os.AsyncTask; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.util.Log; +import android.view.Gravity; +import android.view.MenuItem; +import android.view.ViewGroup; +import android.widget.FrameLayout; +import android.widget.ImageView; +import android.widget.TextView; + +import com.mapbox.geocoder.GeocoderCriteria; +import com.mapbox.geocoder.MapboxGeocoder; +import com.mapbox.geocoder.service.models.GeocoderFeature; +import com.mapbox.geocoder.service.models.GeocoderResponse; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.annotations.MarkerOptions; +import com.mapbox.mapboxsdk.constants.Style; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.maps.Projection; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.testapp.model.constants.AppConstant; + +import java.util.List; + +import retrofit.Callback; +import retrofit.Response; +import retrofit.Retrofit; + +public class GeocoderActivity extends AppCompatActivity { + + private static final String LOG_TAG = "GeocoderActivity"; + + private MapView mapView; + private TextView textView; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_geocoder); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + textView = (TextView) findViewById(R.id.message); + setMessage(getString(R.string.geocoder_instructions)); + + mapView = (MapView) findViewById(R.id.mapView); + mapView.setStyleUrl(Style.getMapboxStreetsUrl(AppConstant.STYLE_VERSION)); + mapView.onCreate(savedInstanceState); + + final ImageView dropPinView = new ImageView(this); + dropPinView.setImageResource(R.drawable.ic_droppin_24dp); + FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT, Gravity.CENTER); + dropPinView.setLayoutParams(params); + mapView.addView(dropPinView); + + mapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull final MapboxMap mapboxMap) { + final Projection projection = mapboxMap.getProjection(); + final int width = mapView.getMeasuredWidth(); + final int height = mapView.getMeasuredHeight(); + + // Click listener + mapboxMap.setOnMapClickListener(new MapboxMap.OnMapClickListener() { + @Override + public void onMapClick(@NonNull LatLng point) { + PointF centerPoint = new PointF(width / 2, (height + dropPinView.getHeight()) / 2); + LatLng centerLatLng = new LatLng(projection.fromScreenLocation(centerPoint)); + + setMessage("Geocoding..."); + + mapboxMap.removeAnnotations(); + mapboxMap.addMarker(new MarkerOptions().position(centerLatLng)); + + geocode(centerLatLng); + } + }); + } + }); + } + + @Override + public void onPause() { + super.onPause(); + mapView.onPause(); + } + + @Override + public void onResume() { + super.onResume(); + mapView.onResume(); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mapView.onDestroy(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mapView.onSaveInstanceState(outState); + } + + /* + * Forward geocoding + */ + + private void geocode(final LatLng point) { + new AsyncTask<Void, Void, Void>() { + + @Override + protected Void doInBackground(Void... params) { + MapboxGeocoder client = new MapboxGeocoder.Builder() + .setAccessToken(getString(R.string.mapbox_access_token)) + .setCoordinates(point.getLongitude(), point.getLatitude()) + .setType(GeocoderCriteria.TYPE_POI) + .build(); + + client.enqueue(new Callback<GeocoderResponse>() + + { + @Override + public void onResponse(Response<GeocoderResponse> response, Retrofit retrofit) { + List<GeocoderFeature> results = response.body().getFeatures(); + if (results.size() > 0) { + String placeName = results.get(0).getPlaceName(); + setSuccess(placeName); + } else { + setMessage("No results."); + } + } + + @Override + public void onFailure(Throwable t) { + setError(t.getMessage()); + } + } + + ); + return null; + } + }.execute(); + } + + /* + * Update text view + */ + + private void setMessage(String message) { + Log.d(LOG_TAG, "Message: " + message); + textView.setText(message); + } + + private void setSuccess(String placeName) { + Log.d(LOG_TAG, "Place name: " + placeName); + textView.setText(placeName); + } + + private void setError(String message) { + Log.e(LOG_TAG, "Error: " + message); + textView.setText("Error: " + message); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/imagegenerator/SnapshotActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/imagegenerator/SnapshotActivity.java new file mode 100644 index 0000000000..93ebdcd157 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/imagegenerator/SnapshotActivity.java @@ -0,0 +1,106 @@ +package com.mapbox.mapboxsdk.testapp.activity.imagegenerator; + +import android.graphics.Bitmap; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.design.widget.FloatingActionButton; +import android.support.v4.content.ContextCompat; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.MenuItem; +import android.view.View; +import android.widget.ImageView; +import android.widget.Toast; + +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; + +public class SnapshotActivity extends AppCompatActivity { + + private MapView mapView; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_snapshot); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mapView = (MapView) findViewById(R.id.mapView); + mapView.onCreate(savedInstanceState); + mapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull final MapboxMap mapboxMap) { + FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab); + fab.setColorFilter(ContextCompat.getColor(SnapshotActivity.this, R.color.primary)); + fab.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + final long startTime = System.nanoTime(); + mapboxMap.snapshot(new MapboxMap.SnapshotReadyCallback() { + @Override + public void onSnapshotReady(Bitmap snapshot) { + long endTime = System.nanoTime(); + long duration = (long) ((endTime - startTime) / 1e6); + ImageView snapshotView = (ImageView) findViewById(R.id.imageView); + snapshotView.setImageBitmap(snapshot); + Toast.makeText(SnapshotActivity.this, String.format("Snapshot taken in %d ms", duration), Toast.LENGTH_LONG).show(); + } + }); + } + }); + } + }); + } + + @Override + public void onResume() { + super.onResume(); + mapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mapView.onPause(); + } + + @Override + public void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mapView.onSaveInstanceState(outState); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mapView.onLowMemory(); + } + + @Override + public void onDestroy() { + super.onDestroy(); + mapView.onDestroy(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/infowindow/InfoWindowActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/infowindow/InfoWindowActivity.java new file mode 100644 index 0000000000..7ac3c59667 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/infowindow/InfoWindowActivity.java @@ -0,0 +1,167 @@ +package com.mapbox.mapboxsdk.testapp.activity.infowindow; + +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.Menu; +import android.view.MenuItem; +import android.widget.Toast; + +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.annotations.Marker; +import com.mapbox.mapboxsdk.annotations.MarkerOptions; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.maps.MapView; + +import java.text.DecimalFormat; + +public class InfoWindowActivity extends AppCompatActivity implements OnMapReadyCallback, MapboxMap.OnInfoWindowCloseListener, MapboxMap.OnMapLongClickListener, MapboxMap.OnInfoWindowClickListener, MapboxMap.OnInfoWindowLongClickListener { + + private MapboxMap mapboxMap; + private MapView mapView; + private Marker customMarker; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_infowindow); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mapView = (MapView) findViewById(R.id.mapView); + mapView.onCreate(savedInstanceState); + mapView.getMapAsync(this); + } + + @Override + public void onMapReady(@NonNull MapboxMap mapboxMap) { + this.mapboxMap = mapboxMap; + addMarkers(); + addInfoWindowListeners(); + } + + private void addMarkers() { + mapboxMap.addMarker(new MarkerOptions() + .title("Intersection") + .snippet("H St NW with 15th St NW") + .position(new LatLng(38.9002073, -77.03364419))); + + mapboxMap.addMarker(new MarkerOptions().title("Intersection") + .snippet("E St NW with 17th St NW") + .position(new LatLng(38.8954236, -77.0394623))); + + Marker marker = mapboxMap.addMarker(new MarkerOptions() + .title("White House") + .snippet("The official residence and principal workplace of the President of the United States, located at 1600 Pennsylvania Avenue NW in Washington, D.C. It has been the residence of every U.S. president since John Adams in 1800.") + .position(new LatLng(38.897705003219784, -77.03655168667463))); + + // open InfoWindow at startup + mapboxMap.selectMarker(marker); + } + + private void addInfoWindowListeners() { + mapboxMap.setOnInfoWindowCloseListener(this); + mapboxMap.setOnMapLongClickListener(this); + mapboxMap.setOnInfoWindowClickListener(this); + mapboxMap.setOnInfoWindowLongClickListener(this); + } + + private void toggleConcurrentInfoWindow(boolean allowConcurrentInfoWindow) { + mapboxMap.deselectMarkers(); + mapboxMap.setAllowConcurrentMultipleOpenInfoWindows(allowConcurrentInfoWindow); + } + + @Override + public boolean onInfoWindowClick(@NonNull Marker marker) { + Toast.makeText(getApplicationContext(), "OnClick: " + marker.getTitle(), Toast.LENGTH_LONG).show(); + // returning true will leave the info window open + return false; + } + + @Override + public void onInfoWindowClose(Marker marker) { + Toast.makeText(getApplicationContext(), "OnClose: " + marker.getTitle(), Toast.LENGTH_LONG).show(); + } + + @Override + public void onInfoWindowLongClick(Marker marker) { + Toast.makeText(getApplicationContext(), "OnLongClick: " + marker.getTitle(), Toast.LENGTH_LONG).show(); + } + + @Override + public void onMapLongClick(@NonNull LatLng point) { + if (customMarker != null) { + // Remove previous added marker + mapboxMap.removeAnnotation(customMarker); + customMarker = null; + } + + // Add marker on long click location with default marker image + customMarker = mapboxMap.addMarker(new MarkerOptions() + .title("Custom Marker") + .snippet(new DecimalFormat("#.#####").format(point.getLatitude()) + ", " + new DecimalFormat("#.#####").format(point.getLongitude())) + .position(point)); + } + + @Override + public void onResume() { + super.onResume(); + mapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mapView.onLowMemory(); + } + + @Override + public boolean onCreateOptionsMenu(Menu menu) { + getMenuInflater().inflate(R.menu.menu_infowindow, menu); + return true; + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case R.id.action_toggle_concurrent_infowindow: + toggleConcurrentInfoWindow(!item.isChecked()); + item.setChecked(!item.isChecked()); + return true; + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/infowindow/InfoWindowAdapterActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/infowindow/InfoWindowAdapterActivity.java new file mode 100644 index 0000000000..2c74702253 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/infowindow/InfoWindowAdapterActivity.java @@ -0,0 +1,144 @@ +package com.mapbox.mapboxsdk.testapp.activity.infowindow; + +import android.graphics.Color; +import android.graphics.PorterDuff; +import android.graphics.drawable.Drawable; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v4.content.ContextCompat; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.MenuItem; +import android.view.View; +import android.widget.TextView; + +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.annotations.Icon; +import com.mapbox.mapboxsdk.annotations.Marker; +import com.mapbox.mapboxsdk.annotations.IconFactory; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.testapp.model.annotations.CityStateMarker; +import com.mapbox.mapboxsdk.testapp.model.annotations.CityStateMarkerOptions; +import com.mapbox.mapboxsdk.maps.MapView; + +public class InfoWindowAdapterActivity extends AppCompatActivity { + + private MapView mapView; + private IconFactory iconFactory; + private Drawable iconDrawable; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_infowindow_adapter); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + iconFactory = IconFactory.getInstance(this); + iconDrawable = ContextCompat.getDrawable(this, R.drawable.ic_location_city_24dp); + + mapView = (MapView) findViewById(R.id.mapView); + mapView.onCreate(savedInstanceState); + mapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull MapboxMap mapboxMap) { + addMarkers(mapboxMap); + addCustomInfoWindowAdapter(mapboxMap); + } + }); + } + + private void addMarkers(MapboxMap mapboxMap){ + mapboxMap.addMarker(generateCityStateMarker("Andorra", 42.505777, 1.52529, "#F44336")); + mapboxMap.addMarker(generateCityStateMarker("Luxembourg", 49.815273, 6.129583, "#3F51B5")); + mapboxMap.addMarker(generateCityStateMarker("Monaco", 43.738418, 7.424616, "#673AB7")); + mapboxMap.addMarker(generateCityStateMarker("Vatican City", 41.902916, 12.453389, "#009688")); + mapboxMap.addMarker(generateCityStateMarker("San Marino", 43.942360, 12.457777, "#795548")); + mapboxMap.addMarker(generateCityStateMarker("Liechtenstein", 47.166000, 9.555373, "#FF5722")); + } + + private CityStateMarkerOptions generateCityStateMarker(String title, double lat, double lng, String color) { + CityStateMarkerOptions marker = new CityStateMarkerOptions(); + marker.title(title); + marker.position(new LatLng(lat, lng)); + marker.infoWindowBackground(color); + + iconDrawable.setColorFilter(Color.parseColor(color), PorterDuff.Mode.SRC_IN); + Icon icon = iconFactory.fromDrawable(iconDrawable); + marker.icon(icon); + return marker; + } + + private void addCustomInfoWindowAdapter(MapboxMap mapboxMap){ + mapboxMap.setInfoWindowAdapter(new MapboxMap.InfoWindowAdapter() { + + private int tenDp = (int) getResources().getDimension(R.dimen.attr_margin); + + @Override + public View getInfoWindow(@NonNull Marker marker) { + TextView textView = new TextView(InfoWindowAdapterActivity.this); + textView.setText(marker.getTitle()); + textView.setTextColor(Color.WHITE); + + if (marker instanceof CityStateMarker) { + CityStateMarker cityStateMarker = (CityStateMarker) marker; + textView.setBackgroundColor(Color.parseColor(cityStateMarker.getInfoWindowBackgroundColor())); + } + + textView.setPadding(tenDp, tenDp, tenDp, tenDp); + return textView; + } + }); + } + + @Override + public void onResume() { + super.onResume(); + mapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mapView.onLowMemory(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/maplayout/DebugModeActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/maplayout/DebugModeActivity.java new file mode 100644 index 0000000000..f5835ab7bd --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/maplayout/DebugModeActivity.java @@ -0,0 +1,131 @@ +package com.mapbox.mapboxsdk.testapp.activity.maplayout; + +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.design.widget.FloatingActionButton; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.util.Log; +import android.view.MenuItem; +import android.view.View; + +import com.mapbox.mapboxsdk.constants.Style; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.testapp.model.constants.AppConstant; + +public class DebugModeActivity extends AppCompatActivity { + + private static final String TAG = "DebugModeActivity"; + + private MapView mapView; + private MapboxMap mapboxMap; + + private int currentStyleIndex = 0; + + private static final String[] STYLES = new String[]{ + Style.getMapboxStreetsUrl(AppConstant.STYLE_VERSION), + Style.getOutdoorsStyleUrl(AppConstant.STYLE_VERSION), + Style.getLightStyleUrl(AppConstant.STYLE_VERSION), + Style.getDarkStyleUrl(AppConstant.STYLE_VERSION), + Style.getSatelliteStyleUrl(AppConstant.STYLE_VERSION), + Style.getSatelliteStreetsStyleUrl(AppConstant.STYLE_VERSION) + }; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_debug_mode); + + final Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mapView = (MapView) findViewById(R.id.mapView); + mapView.setTag(true); + mapView.setStyleUrl(STYLES[currentStyleIndex]); + mapView.onCreate(savedInstanceState); + + mapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull MapboxMap map) { + mapboxMap = map; + } + }); + + FloatingActionButton fabDebug = (FloatingActionButton) findViewById(R.id.fabDebug); + fabDebug.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + if (mapboxMap != null) { + Log.d(TAG, "Debug FAB: isDebug Active? " + mapboxMap.isDebugActive()); + mapboxMap.cycleDebugOptions(); + } + } + }); + + FloatingActionButton fabStyles = (FloatingActionButton) findViewById(R.id.fabStyles); + fabStyles.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + if (mapboxMap != null) { + currentStyleIndex++; + if (currentStyleIndex == STYLES.length) { + currentStyleIndex = 0; + } + mapboxMap.setStyleUrl(STYLES[currentStyleIndex]); + } + } + }); + } + + @Override + public void onResume() { + super.onResume(); + mapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mapView.onLowMemory(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + + default: + return super.onOptionsItemSelected(item); + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/maplayout/DoubleMapActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/maplayout/DoubleMapActivity.java new file mode 100644 index 0000000000..288817d670 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/maplayout/DoubleMapActivity.java @@ -0,0 +1,169 @@ +package com.mapbox.mapboxsdk.testapp.activity.maplayout; + +import android.content.Intent; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v4.app.Fragment; +import android.support.v4.app.FragmentTransaction; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.LayoutInflater; +import android.view.MenuItem; +import android.view.View; +import android.view.ViewGroup; + +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.constants.MyLocationTracking; +import com.mapbox.mapboxsdk.constants.Style; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.maps.TrackingSettings; +import com.mapbox.mapboxsdk.maps.UiSettings; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.testapp.model.constants.AppConstant; + +public class DoubleMapActivity extends AppCompatActivity { + + private static final String TAG_FRAGMENT = "map"; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_map_fragment); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + Fragment mapFragment; + if (savedInstanceState == null) { + FragmentTransaction transaction = getSupportFragmentManager().beginTransaction(); + transaction.add(R.id.fragment_container, mapFragment = new DoubleMapFragment(), TAG_FRAGMENT); + transaction.commit(); + } else { + mapFragment = (DoubleMapFragment) getSupportFragmentManager().findFragmentByTag(TAG_FRAGMENT); + } + } + + public static class DoubleMapFragment extends Fragment { + + private MapView mMapView; + private MapView mMapViewMini; + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { + return inflater.inflate(R.layout.fragment_double_map, container, false); + } + + @Override + public void onViewCreated(View view, Bundle savedInstanceState) { + super.onViewCreated(view, savedInstanceState); + + // MapView large + mMapView = (MapView) view.findViewById(R.id.mapView); + mMapView.onCreate(savedInstanceState); + mMapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull MapboxMap mapboxMap) { + mapboxMap.setStyleUrl(Style.getDarkStyleUrl(AppConstant.STYLE_VERSION)); + + mapboxMap.moveCamera(CameraUpdateFactory.zoomTo(18)); + try { + TrackingSettings settings = mapboxMap.getTrackingSettings(); + settings.setMyLocationTrackingMode(MyLocationTracking.TRACKING_FOLLOW); + } catch (SecurityException e) { + // permission is handled in MainActivity + getActivity().finish(); + } + } + }); + + // MapView mini + mMapViewMini = (MapView) view.findViewById(R.id.mini_map); + mMapViewMini.onCreate(savedInstanceState); + mMapViewMini.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull MapboxMap mapboxMap) { + mapboxMap.setStyleUrl(Style.getLightStyleUrl(AppConstant.STYLE_VERSION)); + mapboxMap.moveCamera(CameraUpdateFactory.zoomTo(4)); + + UiSettings uiSettings = mapboxMap.getUiSettings(); + uiSettings.setAllGesturesEnabled(false); + uiSettings.setCompassEnabled(false); + uiSettings.setAttributionEnabled(false); + uiSettings.setLogoEnabled(false); + + try { + TrackingSettings settings = mapboxMap.getTrackingSettings(); + settings.setMyLocationTrackingMode(MyLocationTracking.TRACKING_FOLLOW); + } catch (SecurityException e) { + // permission is handled in MainActivity + getActivity().finish(); + } + + mapboxMap.setOnMapClickListener(new MapboxMap.OnMapClickListener() { + @Override + public void onMapClick(@NonNull LatLng point) { + // test if we can open 2 activities after each other + startActivity(new Intent(mMapViewMini.getContext(), DoubleMapActivity.class)); + } + }); + } + }); + } + + @Override + public void onResume() { + super.onResume(); + mMapView.onResume(); + mMapViewMini.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mMapView.onPause(); + mMapViewMini.onPause(); + } + + @Override + public void onDestroy() { + super.onDestroy(); + mMapView.onDestroy(); + mMapViewMini.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mMapView.onLowMemory(); + mMapViewMini.onLowMemory(); + } + + @Override + public void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mMapView.onSaveInstanceState(outState); + mMapViewMini.onSaveInstanceState(outState); + } + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } +}
\ No newline at end of file diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/maplayout/MapPaddingActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/maplayout/MapPaddingActivity.java new file mode 100644 index 0000000000..62762f7116 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/maplayout/MapPaddingActivity.java @@ -0,0 +1,150 @@ +package com.mapbox.mapboxsdk.testapp.activity.maplayout; + +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.Menu; +import android.view.MenuItem; + +import com.mapbox.mapboxsdk.annotations.MarkerOptions; +import com.mapbox.mapboxsdk.camera.CameraPosition; +import com.mapbox.mapboxsdk.constants.MyLocationTracking; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.maps.TrackingSettings; +import com.mapbox.mapboxsdk.testapp.R; + +public class MapPaddingActivity extends AppCompatActivity { + + private MapView mMapView; + private MapboxMap mMapboxMap; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_map_padding); + + final Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mMapView = (MapView) findViewById(R.id.mapView); + mMapView.setTag(true); + mMapView.onCreate(savedInstanceState); + + mMapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull MapboxMap mapboxMap) { + mMapboxMap = mapboxMap; + + int paddingLeft = (int) getResources().getDimension(R.dimen.map_padding_left); + int paddingBottom = (int) getResources().getDimension(R.dimen.map_padding_bottom); + int paddingRight = (int) getResources().getDimension(R.dimen.map_padding_right); + mapboxMap.setPadding(paddingLeft, toolbar.getHeight(), paddingRight, paddingBottom); + + moveToBangalore(); + } + }); + } + + @Override + public void onResume() { + super.onResume(); + mMapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mMapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mMapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mMapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mMapView.onLowMemory(); + } + + @Override + public boolean onCreateOptionsMenu(Menu menu) { + getMenuInflater().inflate(R.menu.menu_padding, menu); + return true; + } + + private void toggleGps(boolean enable) { + try { + // Enable user location + mMapboxMap.setMyLocationEnabled(enable); + + TrackingSettings trackingSettings = mMapboxMap.getTrackingSettings(); + trackingSettings.setDismissTrackingOnGesture(false); + trackingSettings.setMyLocationTrackingMode(enable ? MyLocationTracking.TRACKING_FOLLOW : MyLocationTracking.TRACKING_NONE); + } catch (SecurityException e) { + // permission not granted is handled in FeatureOverviewActivity + finish(); + } + } + + private void moveToBangalore() { + toggleGps(false); + + LatLng bangalore = new LatLng(12.9810816, 77.6368034); + CameraPosition cameraPosition = new CameraPosition.Builder() + .zoom(16) + .target(bangalore) + .bearing(40) + .tilt(45) + .build(); + + mMapboxMap.moveCamera(CameraUpdateFactory.newCameraPosition(cameraPosition)); + mMapboxMap.addMarker(new MarkerOptions().title("Center map").position(bangalore)); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + + case R.id.action_user_tracking: + if (mMapboxMap != null) { + toggleGps(true); + } + return true; + + case R.id.action_bangalore: + if (mMapboxMap != null) { + moveToBangalore(); + } + return true; + + default: + return super.onOptionsItemSelected(item); + } + } + +} + diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/offline/OfflineActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/offline/OfflineActivity.java new file mode 100644 index 0000000000..fde46b1cab --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/offline/OfflineActivity.java @@ -0,0 +1,356 @@ +package com.mapbox.mapboxsdk.testapp.activity.offline; + +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.text.TextUtils; +import android.util.Log; +import android.view.MenuItem; +import android.view.View; +import android.widget.Button; +import android.widget.ProgressBar; +import android.widget.Toast; +import com.mapbox.mapboxsdk.camera.CameraPosition; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.constants.Style; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.geometry.LatLngBounds; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.offline.OfflineManager; +import com.mapbox.mapboxsdk.offline.OfflineRegion; +import com.mapbox.mapboxsdk.offline.OfflineRegionError; +import com.mapbox.mapboxsdk.offline.OfflineRegionStatus; +import com.mapbox.mapboxsdk.offline.OfflineTilePyramidRegionDefinition; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.testapp.model.constants.AppConstant; +import com.mapbox.mapboxsdk.testapp.model.other.OfflineDownloadRegionDialog; +import com.mapbox.mapboxsdk.testapp.model.other.OfflineListRegionsDialog; +import org.json.JSONObject; +import java.util.ArrayList; + +public class OfflineActivity extends AppCompatActivity + implements OfflineDownloadRegionDialog.DownloadRegionDialogListener { + + private final static String LOG_TAG = "OfflineActivity"; + + // JSON encoding/decoding + public final static String JSON_CHARSET = "UTF-8"; + public final static String JSON_FIELD_REGION_NAME = "FIELD_REGION_NAME"; + + /* + * UI elements + */ + private MapView mMapView; + private MapboxMap mMapboxMap; + private ProgressBar mProgressBar; + private Button downloadRegion; + private Button listRegions; + + private boolean isEndNotified; + + /* + * Offline objects + */ + private OfflineManager mOfflineManager; + private OfflineRegion mOfflineRegion; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_offline); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + // Set up map + mMapView = (MapView) findViewById(R.id.mapView); + mMapView.setStyleUrl(Style.getMapboxStreetsUrl(AppConstant.STYLE_VERSION)); + mMapView.onCreate(savedInstanceState); + mMapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull MapboxMap mapboxMap) { + Log.d(LOG_TAG, "Map is ready"); + mMapboxMap = mapboxMap; + + // Set initial position to UNHQ in NYC + mapboxMap.moveCamera(CameraUpdateFactory.newCameraPosition( + new CameraPosition.Builder() + .target(new LatLng(40.749851, -73.967966)) + .zoom(14) + .bearing(0) + .tilt(0) + .build())); + } + }); + + // The progress bar + mProgressBar = (ProgressBar) findViewById(R.id.progress_bar); + + // Set up button listeners + downloadRegion = (Button) findViewById(R.id.button_download_region); + downloadRegion.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + handleDownloadRegion(); + } + }); + + listRegions = (Button) findViewById(R.id.button_list_regions); + listRegions.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + handleListRegions(); + } + }); + + // Set up the OfflineManager + mOfflineManager = OfflineManager.getInstance(this); + } + + @Override + public void onResume() { + super.onResume(); + mMapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mMapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mMapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mMapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mMapView.onLowMemory(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } + + /* + * Buttons logic + */ + + private void handleDownloadRegion() { + Log.d(LOG_TAG, "handleDownloadRegion"); + + // Show dialog + OfflineDownloadRegionDialog offlineDownloadRegionDialog = new OfflineDownloadRegionDialog(); + offlineDownloadRegionDialog.show(getSupportFragmentManager(), "download"); + } + + private void handleListRegions() { + Log.d(LOG_TAG, "handleListRegions"); + + // Query the DB asynchronously + mOfflineManager.listOfflineRegions(new OfflineManager.ListOfflineRegionsCallback() { + @Override + public void onList(OfflineRegion[] offlineRegions) { + // Check result + if (offlineRegions == null || offlineRegions.length == 0) { + Toast.makeText(OfflineActivity.this, "You have no regions yet.", Toast.LENGTH_SHORT).show(); + return; + } + + // Get regions info + ArrayList<String> offlineRegionsNames = new ArrayList<>(); + for (OfflineRegion offlineRegion : offlineRegions) { + offlineRegionsNames.add(getRegionName(offlineRegion)); + } + + // Create args + Bundle args = new Bundle(); + args.putStringArrayList(OfflineListRegionsDialog.ITEMS, offlineRegionsNames); + + // Show dialog + OfflineListRegionsDialog offlineListRegionsDialog = new OfflineListRegionsDialog(); + offlineListRegionsDialog.setArguments(args); + offlineListRegionsDialog.show(getSupportFragmentManager(), "list"); + } + + @Override + public void onError(String error) { + Log.e(LOG_TAG, "Error: " + error); + } + + private String getRegionName(OfflineRegion offlineRegion) { + String regionName; + + try { + byte[] metadata = offlineRegion.getMetadata(); + String json = new String(metadata, JSON_CHARSET); + JSONObject jsonObject = new JSONObject(json); + regionName = jsonObject.getString(JSON_FIELD_REGION_NAME); + } catch (Exception e) { + Log.e(LOG_TAG, "Failed to decode metadata: " + e.getMessage()); + regionName = "Region " + offlineRegion.getID(); + } + + return regionName; + } + }); + } + + /* + * Dialogs + */ + + @Override + public void onDownloadRegionDialogPositiveClick(final String regionName) { + if (TextUtils.isEmpty(regionName)) { + Toast.makeText(OfflineActivity.this, "Region name cannot be empty.", Toast.LENGTH_SHORT).show(); + return; + } + + // Start progress bar + Log.d(LOG_TAG, "Download started: " + regionName); + startProgress(); + + // Definition + String styleURL = mMapboxMap.getStyleUrl(); + LatLngBounds bounds = mMapboxMap.getProjection().getVisibleRegion().latLngBounds; + double minZoom = mMapboxMap.getCameraPosition().zoom; + double maxZoom = mMapboxMap.getMaxZoom(); + float pixelRatio = this.getResources().getDisplayMetrics().density; + OfflineTilePyramidRegionDefinition definition = new OfflineTilePyramidRegionDefinition( + styleURL, bounds, minZoom, maxZoom, pixelRatio); + + // Sample way of encoding metadata from a JSONObject + byte[] metadata; + try { + JSONObject jsonObject = new JSONObject(); + jsonObject.put(JSON_FIELD_REGION_NAME, regionName); + String json = jsonObject.toString(); + metadata = json.getBytes(JSON_CHARSET); + } catch (Exception e) { + Log.e(LOG_TAG, "Failed to encode metadata: " + e.getMessage()); + metadata = null; + } + + // Create region + mOfflineManager.createOfflineRegion(definition, metadata, new OfflineManager.CreateOfflineRegionCallback() { + @Override + public void onCreate(OfflineRegion offlineRegion) { + Log.d(LOG_TAG, "Offline region created: " + regionName); + mOfflineRegion = offlineRegion; + launchDownload(); + } + + @Override + public void onError(String error) { + Log.e(LOG_TAG, "Error: " + error); + } + }); + } + + private void launchDownload() { + // Set an observer + mOfflineRegion.setObserver(new OfflineRegion.OfflineRegionObserver() { + @Override + public void onStatusChanged(OfflineRegionStatus status) { + // Compute a percentage + double percentage = status.getRequiredResourceCount() >= 0 ? + (100.0 * status.getCompletedResourceCount() / status.getRequiredResourceCount()) : + 0.0; + + if (status.isComplete()) { + // Download complete + endProgress("Region downloaded successfully."); + return; + } else if (status.isRequiredResourceCountPrecise()) { + // Switch to determinate state + setPercentage((int) Math.round(percentage)); + } + + // Debug + Log.d(LOG_TAG, String.format("%s/%s resources; %s bytes downloaded.", + String.valueOf(status.getCompletedResourceCount()), + String.valueOf(status.getRequiredResourceCount()), + String.valueOf(status.getCompletedResourceSize()))); + } + + @Override + public void onError(OfflineRegionError error) { + Log.e(LOG_TAG, "onError reason: " + error.getReason()); + Log.e(LOG_TAG, "onError message: " + error.getMessage()); + } + + @Override + public void mapboxTileCountLimitExceeded(long limit) { + Log.e(LOG_TAG, "Mapbox tile count limit exceeded: " + limit); + } + }); + + // Change the region state + mOfflineRegion.setDownloadState(OfflineRegion.STATE_ACTIVE); + } + + /* + * Progress bar + */ + + private void startProgress() { + // Disable buttons + downloadRegion.setEnabled(false); + listRegions.setEnabled(false); + + // Start and show the progress bar + isEndNotified = false; + mProgressBar.setIndeterminate(true); + mProgressBar.setVisibility(View.VISIBLE); + } + + private void setPercentage(final int percentage) { + mProgressBar.setIndeterminate(false); + mProgressBar.setProgress(percentage); + } + + private void endProgress(final String message) { + // Don't notify more than once + if (isEndNotified) return; + + // Enable buttons + downloadRegion.setEnabled(true); + listRegions.setEnabled(true); + + // Stop and hide the progress bar + isEndNotified = true; + mProgressBar.setIndeterminate(false); + mProgressBar.setVisibility(View.GONE); + + // Show a toast + Toast.makeText(OfflineActivity.this, message, Toast.LENGTH_LONG).show(); + } + +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/userlocation/MyLocationDrawableActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/userlocation/MyLocationDrawableActivity.java new file mode 100644 index 0000000000..a4a283907e --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/userlocation/MyLocationDrawableActivity.java @@ -0,0 +1,136 @@ +package com.mapbox.mapboxsdk.testapp.activity.userlocation; + +import android.graphics.Color; +import android.location.Location; +import android.os.Bundle; +import android.support.annotation.Nullable; +import android.support.v4.content.ContextCompat; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.MenuItem; +import android.view.View; +import android.view.ViewGroup; +import com.mapbox.mapboxsdk.camera.CameraPosition; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.constants.Style; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.location.LocationListener; +import com.mapbox.mapboxsdk.location.LocationServices; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.MapboxMapOptions; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; +import com.mapbox.mapboxsdk.testapp.model.constants.AppConstant; + +public class MyLocationDrawableActivity extends AppCompatActivity implements LocationListener { + + private MapView mapView; + private MapboxMap mapboxMap; + private Location location; + private boolean firstRun; + + @Override + protected void onCreate(@Nullable Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_my_location_customization); + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + final ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + findViewById(R.id.progress).setVisibility(View.GONE); + location = LocationServices.getLocationServices(this).getLastLocation(); + + MapboxMapOptions mapboxMapOptions = new MapboxMapOptions(); + mapboxMapOptions.accessToken(getString(R.string.mapbox_access_token)); + mapboxMapOptions.styleUrl(Style.getMapboxStreetsUrl(AppConstant.STYLE_VERSION)); + mapboxMapOptions.locationEnabled(true); + mapboxMapOptions.camera(new CameraPosition.Builder() + .target(location != null ? new LatLng(location) : new LatLng(0, 0)) + .zoom(11) + .tilt(25) + .build()); + + mapboxMapOptions.myLocationForegroundDrawables(ContextCompat.getDrawable(this, R.drawable.ic_chelsea), + ContextCompat.getDrawable(this, R.drawable.ic_chelsea)); + mapboxMapOptions.myLocationBackgroundDrawable(ContextCompat.getDrawable(this, R.drawable.ic_arsenal)); + mapboxMapOptions.myLocationForegroundTintColor(Color.GREEN); + mapboxMapOptions.myLocationBackgroundTintColor(Color.YELLOW); + mapboxMapOptions.myLocationBackgroundPadding(new int[]{0, 0, + (int) getResources().getDimension(R.dimen.locationview_background_drawable_padding), + (int) getResources().getDimension(R.dimen.locationview_background_drawable_padding)}); + + mapboxMapOptions.myLocationAccuracyTint(Color.RED); + mapboxMapOptions.myLocationAccuracyAlpha(155); + + mapView = new MapView(this, mapboxMapOptions); + ViewGroup parent = (ViewGroup) findViewById(R.id.container); + parent.addView(mapView); + + mapView.onCreate(savedInstanceState); + mapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(MapboxMap map) { + mapboxMap = map; + } + }); + + LocationServices.getLocationServices(this).addLocationListener(this); + } + + @Override + public void onLocationChanged(Location location) { + if (mapboxMap != null && firstRun) { + mapboxMap.moveCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(location), 10)); + firstRun = false; + } + } + + @Override + public void onResume() { + super.onResume(); + mapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mapView.onLowMemory(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } + +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/userlocation/MyLocationTintActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/userlocation/MyLocationTintActivity.java new file mode 100644 index 0000000000..f665b88f60 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/userlocation/MyLocationTintActivity.java @@ -0,0 +1,188 @@ +package com.mapbox.mapboxsdk.testapp.activity.userlocation; + +import android.Manifest; +import android.app.Activity; +import android.content.pm.PackageManager; +import android.location.Location; +import android.os.Bundle; +import android.support.annotation.IdRes; +import android.support.annotation.NonNull; +import android.support.annotation.Nullable; +import android.support.annotation.UiThread; +import android.support.v4.app.ActivityCompat; +import android.support.v4.content.ContextCompat; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.MenuItem; +import android.view.View; + +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.location.LocationListener; +import com.mapbox.mapboxsdk.location.LocationServices; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.maps.widgets.MyLocationViewSettings; +import com.mapbox.mapboxsdk.testapp.R; + +public class MyLocationTintActivity extends AppCompatActivity implements LocationListener { + + private MapView mapView; + private MapboxMap map; + private boolean firstRun; + + private static final int PERMISSIONS_LOCATION = 0; + + @Override + protected void onCreate(@Nullable Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_my_location_dot_color); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mapView = (MapView) findViewById(R.id.mapView); + mapView.onCreate(savedInstanceState); + mapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(MapboxMap mapboxMap) { + map = mapboxMap; + toggleGps(!mapboxMap.isMyLocationEnabled()); + + final MyLocationViewSettings myLocationViewSettings = mapboxMap.getMyLocationViewSettings(); + + // handle default button clicks + ViewUtils.attachClickListener(MyLocationTintActivity.this, R.id.default_user_dot_coloring_button,new View.OnClickListener() { + @Override + public void onClick(View view) { + myLocationViewSettings.setAccuracyTintColor(ContextCompat.getColor(MyLocationTintActivity.this, R.color.my_location_ring)); + myLocationViewSettings.setForegroundTintColor(ContextCompat.getColor(MyLocationTintActivity.this, R.color.mapbox_blue)); + } + }); + + // handle tint user dot button clicks + ViewUtils.attachClickListener(MyLocationTintActivity.this, R.id.tint_user_dot_button,new View.OnClickListener() { + @Override + public void onClick(View view) { + myLocationViewSettings.setAccuracyTintColor(ContextCompat.getColor(MyLocationTintActivity.this, R.color.mapbox_green)); + myLocationViewSettings.setForegroundTintColor(ContextCompat.getColor(MyLocationTintActivity.this, R.color.mapbox_green)); + } + }); + + // handle tint accuracy ring button clicks + ViewUtils.attachClickListener(MyLocationTintActivity.this, R.id.user_accuracy_ring_tint_button,new View.OnClickListener() { + @Override + public void onClick(View view) { + myLocationViewSettings.setAccuracyTintColor(ContextCompat.getColor(MyLocationTintActivity.this, R.color.accent)); + myLocationViewSettings.setForegroundTintColor(ContextCompat.getColor(MyLocationTintActivity.this, R.color.mapbox_blue)); + } + }); + } + }); + + LocationServices.getLocationServices(this).addLocationListener(this); + } + + @Override + public void onLocationChanged(Location location) { + if (map != null && firstRun) { + map.moveCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(location), 15)); + firstRun = false; + } + } + + @Override + public void onResume() { + super.onResume(); + mapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mapView.onPause(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mapView.onLowMemory(); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mapView.onDestroy(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mapView.onSaveInstanceState(outState); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } + + @UiThread + public void toggleGps(boolean enableGps) { + if (enableGps) { + if ((ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) || + (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED)) { + ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_COARSE_LOCATION, Manifest.permission.ACCESS_FINE_LOCATION}, PERMISSIONS_LOCATION); + } else { + enableLocation(true); + } + } else { + enableLocation(false); + } + } + + private void enableLocation(boolean enabled) { + if (enabled) { + map.setMyLocationEnabled(true); + if (map.getMyLocation() != null) { + map.moveCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(map.getMyLocation().getLatitude(), map.getMyLocation().getLongitude()), 15)); + } + } else { + map.setMyLocationEnabled(false); + } + } + + @Override + public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults) { + switch (requestCode) { + case PERMISSIONS_LOCATION: { + if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { + enableLocation(true); + } + } + } + } + + private static class ViewUtils { + + public static void attachClickListener(@NonNull Activity activity, @IdRes int buttonId, @Nullable View.OnClickListener clickListener) { + View view = activity.findViewById(buttonId); + if(view!=null){ + view.setOnClickListener(clickListener); + } + } + } +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/userlocation/MyLocationToggleActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/userlocation/MyLocationToggleActivity.java new file mode 100644 index 0000000000..b92bb5937c --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/userlocation/MyLocationToggleActivity.java @@ -0,0 +1,160 @@ +package com.mapbox.mapboxsdk.testapp.activity.userlocation; + +import android.Manifest; +import android.content.pm.PackageManager; +import android.location.Location; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.annotation.Nullable; +import android.support.annotation.UiThread; +import android.support.design.widget.FloatingActionButton; +import android.support.v4.app.ActivityCompat; +import android.support.v4.content.ContextCompat; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.MenuItem; +import android.view.View; +import com.mapbox.mapboxsdk.camera.CameraPosition; +import com.mapbox.mapboxsdk.constants.Style; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.testapp.R; + +public class MyLocationToggleActivity extends AppCompatActivity { + + private MapView mapView; + private MapboxMap mapboxMap; + private FloatingActionButton locationToggleFAB; + + private static final int PERMISSIONS_LOCATION = 0; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_my_location_toggle); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + final ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayShowTitleEnabled(true); + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mapView = (MapView) findViewById(R.id.mapView); + mapView.onCreate(savedInstanceState); + mapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(MapboxMap map) { + mapboxMap = map; + } + }); + + locationToggleFAB = (FloatingActionButton) findViewById(R.id.fabLocationToggle); + locationToggleFAB.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + if (mapboxMap != null) { + toggleGps(!mapboxMap.isMyLocationEnabled()); + } + } + }); + } + + @Override + public void onResume() { + super.onResume(); + mapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mapView.onLowMemory(); + } + + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + default: + return false; + } + } + + @UiThread + public void toggleGps(boolean enableGps) { + if (enableGps) { + if ((ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) || + (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED)) { + ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_COARSE_LOCATION, Manifest.permission.ACCESS_FINE_LOCATION}, PERMISSIONS_LOCATION); + } else { + enableLocation(true); + } + } else { + enableLocation(false); + } + } + + private void enableLocation(boolean enabled) { + if (enabled) { + mapboxMap.setOnMyLocationChangeListener(new MapboxMap.OnMyLocationChangeListener() { + @Override + public void onMyLocationChange(@Nullable Location location) { + if (location != null) { + mapboxMap.setCameraPosition(new CameraPosition.Builder() + .target(new LatLng(location)) + .zoom(16) + .bearing(0) + .tilt(0) + .build()); + mapboxMap.setOnMyLocationChangeListener(null); + } + } + }); + locationToggleFAB.setImageResource(R.drawable.ic_location_disabled_24dp); + } else { + locationToggleFAB.setImageResource(R.drawable.ic_my_location_24dp); + } + + mapboxMap.setMyLocationEnabled(enabled); + } + + @Override + public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults) { + switch (requestCode) { + case PERMISSIONS_LOCATION: { + if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { + enableLocation(true); + } + } + } + } + +} diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/userlocation/MyLocationTrackingModeActivity.java b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/userlocation/MyLocationTrackingModeActivity.java new file mode 100644 index 0000000000..fcd61e70b4 --- /dev/null +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/main/java/com/mapbox/mapboxsdk/testapp/activity/userlocation/MyLocationTrackingModeActivity.java @@ -0,0 +1,242 @@ +package com.mapbox.mapboxsdk.testapp.activity.userlocation; + +import android.location.Location; +import android.os.Bundle; +import android.support.annotation.NonNull; +import android.support.annotation.Nullable; +import android.support.design.widget.Snackbar; +import android.support.v7.app.ActionBar; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.widget.AdapterView; +import android.widget.ArrayAdapter; +import android.widget.Spinner; +import android.widget.Toast; +import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; +import com.mapbox.mapboxsdk.constants.MapboxConstants; +import com.mapbox.mapboxsdk.constants.MyBearingTracking; +import com.mapbox.mapboxsdk.constants.MyLocationTracking; +import com.mapbox.mapboxsdk.geometry.LatLng; +import com.mapbox.mapboxsdk.location.LocationServices; +import com.mapbox.mapboxsdk.maps.MapView; +import com.mapbox.mapboxsdk.maps.MapboxMap; +import com.mapbox.mapboxsdk.maps.OnMapReadyCallback; +import com.mapbox.mapboxsdk.maps.TrackingSettings; +import com.mapbox.mapboxsdk.testapp.R; + +public class MyLocationTrackingModeActivity extends AppCompatActivity implements MapboxMap.OnMyLocationChangeListener, AdapterView.OnItemSelectedListener { + + private MapView mMapView; + private MapboxMap mMapboxMap; + private Spinner mLocationSpinner, mBearingSpinner; + private Location mLocation; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_my_location_tracking); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + final ActionBar actionBar = getSupportActionBar(); + if (actionBar != null) { + actionBar.setDisplayShowTitleEnabled(false); + actionBar.setDisplayHomeAsUpEnabled(true); + actionBar.setDisplayShowHomeEnabled(true); + } + + mMapView = (MapView) findViewById(R.id.mapView); + mMapView.onCreate(savedInstanceState); + mMapView.getMapAsync(new OnMapReadyCallback() { + @Override + public void onMapReady(@NonNull MapboxMap mapboxMap) { + mMapboxMap = mapboxMap; + + // disable dismissal when a gesture occurs + mMapboxMap.getTrackingSettings().setDismissLocationTrackingOnGesture(false); + mMapboxMap.getTrackingSettings().setDismissBearingTrackingOnGesture(false); + + mapboxMap.setOnMyLocationChangeListener(MyLocationTrackingModeActivity.this); + + ArrayAdapter<CharSequence> locationTrackingAdapter = ArrayAdapter.createFromResource(actionBar.getThemedContext(), R.array.user_tracking_mode, android.R.layout.simple_spinner_item); + locationTrackingAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + mLocationSpinner = (Spinner) findViewById(R.id.spinner_location); + mLocationSpinner.setAdapter(locationTrackingAdapter); + mLocationSpinner.setOnItemSelectedListener(MyLocationTrackingModeActivity.this); + + ArrayAdapter<CharSequence> bearingTrackingAdapter = ArrayAdapter.createFromResource(actionBar.getThemedContext(), R.array.user_bearing_mode, android.R.layout.simple_spinner_item); + bearingTrackingAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); + mBearingSpinner = (Spinner) findViewById(R.id.spinner_bearing); + mBearingSpinner.setAdapter(bearingTrackingAdapter); + mBearingSpinner.setOnItemSelectedListener(MyLocationTrackingModeActivity.this); + + mapboxMap.setOnMyLocationTrackingModeChangeListener(new MapboxMap.OnMyLocationTrackingModeChangeListener() { + @Override + public void onMyLocationTrackingModeChange(@MyLocationTracking.Mode int myLocationTrackingMode) { + if (MyLocationTracking.TRACKING_NONE == myLocationTrackingMode) { + mLocationSpinner.setOnItemSelectedListener(null); + mLocationSpinner.setSelection(0); + mLocationSpinner.setOnItemSelectedListener(MyLocationTrackingModeActivity.this); + } + } + }); + + mapboxMap.setOnMyBearingTrackingModeChangeListener(new MapboxMap.OnMyBearingTrackingModeChangeListener() { + @Override + public void onMyBearingTrackingModeChange(@MyBearingTracking.Mode int myBearingTrackingMode) { + if (MyBearingTracking.NONE == myBearingTrackingMode) { + mBearingSpinner.setOnItemSelectedListener(null); + mBearingSpinner.setSelection(0); + mBearingSpinner.setOnItemSelectedListener(MyLocationTrackingModeActivity.this); + } + } + }); + + + mLocation = LocationServices.getLocationServices(MyLocationTrackingModeActivity.this).getLastLocation(); + if(mLocation!=null){ + setInitialPosition(new LatLng(mLocation)); + } + } + }); + } + + private void setInitialPosition(LatLng latLng){ + mMapboxMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latLng, 14)); + mMapboxMap.setMyLocationEnabled(true); + mLocationSpinner.setEnabled(true); + mBearingSpinner.setEnabled(true); + } + + @Override + public void onMyLocationChange(@Nullable Location location) { + if (location != null) { + if (mLocation == null) { + // initial location to reposition map + setInitialPosition(new LatLng(location)); + } + mLocation = location; + showSnackBar(); + } + } + + private void showSnackBar() { + String desc = "Loc Chg: "; + boolean noInfo = true; + if (mLocation.hasSpeed()) { + desc += String.format(MapboxConstants.MAPBOX_LOCALE, "Spd = %.1f km/h ", mLocation.getSpeed() * 3.6f); + noInfo = false; + } + if (mLocation.hasAltitude()) { + desc += String.format(MapboxConstants.MAPBOX_LOCALE, "Alt = %.0f m ", mLocation.getAltitude()); + noInfo = false; + } + if (mLocation.hasAccuracy()) { + desc += String.format(MapboxConstants.MAPBOX_LOCALE, "Acc = %.0f m", mLocation.getAccuracy()); + } + + if (noInfo) { + desc += "No extra info"; + } + Snackbar.make(findViewById(android.R.id.content), desc, Snackbar.LENGTH_SHORT).show(); + } + + @Override + public void onItemSelected(AdapterView<?> parent, View view, int position, long id) throws SecurityException { + TrackingSettings trackingSettings = mMapboxMap.getTrackingSettings(); + if (parent.getId() == R.id.spinner_location) { + switch (position) { + case 0: + trackingSettings.setMyLocationTrackingMode(MyLocationTracking.TRACKING_NONE); + break; + + case 1: + trackingSettings.setMyLocationTrackingMode(MyLocationTracking.TRACKING_FOLLOW); + break; + } + } else if (parent.getId() == R.id.spinner_bearing) { + switch (position) { + case 0: + trackingSettings.setMyBearingTrackingMode(MyBearingTracking.NONE); + break; + + case 1: + trackingSettings.setMyBearingTrackingMode(MyBearingTracking.GPS); + break; + + case 2: + trackingSettings.setMyBearingTrackingMode(MyBearingTracking.COMPASS); + break; + } + } + } + + @Override + public void onNothingSelected(AdapterView<?> parent) { + + } + + @Override + public void onResume() { + super.onResume(); + mMapView.onResume(); + } + + @Override + public void onPause() { + super.onPause(); + mMapView.onPause(); + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + mMapView.onSaveInstanceState(outState); + } + + @Override + protected void onDestroy() { + super.onDestroy(); + mMapView.onDestroy(); + } + + @Override + public void onLowMemory() { + super.onLowMemory(); + mMapView.onLowMemory(); + } + + @Override + public boolean onCreateOptionsMenu(Menu menu) { + getMenuInflater().inflate(R.menu.menu_tracking, menu); + return true; + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + boolean state; + switch (item.getItemId()) { + case android.R.id.home: + onBackPressed(); + return true; + case R.id.action_toggle_dismissible_tracking: + state = !item.isChecked(); + mMapboxMap.getTrackingSettings().setDismissLocationTrackingOnGesture(state); + Toast.makeText(this, "Dismiss tracking mode on gesture = " + state, Toast.LENGTH_SHORT).show(); + item.setChecked(state); + return true; + case R.id.action_toggle_dismissible_bearing: + state = !item.isChecked(); + mMapboxMap.getTrackingSettings().setDismissBearingTrackingOnGesture(state); + Toast.makeText(this, "Dismiss bearing mode on gesture = " + state, Toast.LENGTH_SHORT).show(); + item.setChecked(state); + default: + return super.onOptionsItemSelected(item); + } + } + +} |