raghav-coder
4/13/2018 - 4:06 AM
Share Intent
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.android.implicitintents;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.support.v4.app.ShareCompat;
import android.support.v4.app.ShareCompat.IntentBuilder;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Toast;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
/**
* This method is called when the Open Website button is clicked. It will open the website
* specified by the URL represented by the variable urlAsString using implicit Intents.
*
* @param v Button that was clicked.
*/
public void onClickOpenWebpageButton(View v) {
String urlAsString = "http://www.udacity.com";
openWebPage(urlAsString);
}
/**
* This method is called when the Open Location in Map button is clicked. It will open the
* a map to the location represented by the variable addressString using implicit Intents.
*
* @param v Button that was clicked.
*/
public void onClickOpenAddressButton(View v) {
String addressString = "1600 Amphitheatre Parkway, CA";
Uri.Builder builder = new Uri.Builder();
builder.scheme("geo")
.path("0,0")
.query(addressString);
Uri addressUri = builder.build();
showMap(addressUri);
}
/**
* This method is called when the Share Text Content button is clicked. It will simply share
* the text contained within the String textThatYouWantToShare.
*
* @param v Button that was clicked.
*/
// @@2
public void onClickShareTextButton(View v) {
// COMPLETED (5) Specify a String you'd like to share
/* Create the String that you want to share */
String textThatYouWantToShare =
"Sharing the coolest thing I've learned so far. You should " +
"check out Udacity and Google's Android Nanodegree!";
// COMPLETED (6) Replace the Toast with shareText, passing in the String from step 5
/* Send that text to our method that will share it. */
shareText(textThatYouWantToShare);
}
/**
* This is where you will create and fire off your own implicit Intent. Yours will be very
* similar to what I've done above. You can view a list of implicit Intents on the Common
* Intents page from the developer documentation.
*
* @see <http://developer.android.com/guide/components/intents-common.html/>
*
* @param v Button that was clicked.
*/
public void createYourOwn(View v) {
Toast.makeText(this,
"TODO: Create Your Own Implicit Intent",
Toast.LENGTH_SHORT)
.show();
}
/**
* This method fires off an implicit Intent to open a webpage.
*
* @param url Url of webpage to open. Should start with http:// or https:// as that is the
* scheme of the URI expected with this Intent according to the Common Intents page
*/
private void openWebPage(String url) {
/*
* We wanted to demonstrate the Uri.parse method because its usage occurs frequently. You
* could have just as easily passed in a Uri as the parameter of this method.
*/
Uri webpage = Uri.parse(url);
/*
* Here, we create the Intent with the action of ACTION_VIEW. This action allows the user
* to view particular content. In this case, our webpage URL.
*/
Intent intent = new Intent(Intent.ACTION_VIEW, webpage);
/*
* This is a check we perform with every implicit Intent that we launch. In some cases,
* the device where this code is running might not have an Activity to perform the action
* with the data we've specified. Without this check, in those cases your app would crash.
*/
if (intent.resolveActivity(getPackageManager()) != null) {
startActivity(intent);
}
}
/**
* This method will fire off an implicit Intent to view a location on a map.
*
* When constructing implicit Intents, you can use either the setData method or specify the
* URI as the second parameter of the Intent's constructor,
* as I do in {@link #openWebPage(String)}
*
* @param geoLocation The Uri representing the location that will be opened in the map
*/
private void showMap(Uri geoLocation) {
/*
* Again, we create an Intent with the action, ACTION_VIEW because we want to VIEW the
* contents of this Uri.
*/
Intent intent = new Intent(Intent.ACTION_VIEW);
/*
* Using setData to set the Uri of this Intent has the exact same affect as passing it in
* the Intent's constructor. This is simply an alternate way of doing this.
*/
intent.setData(geoLocation);
if (intent.resolveActivity(getPackageManager()) != null) {
startActivity(intent);
}
}
// COMPLETED (1) Create a void method called shareText that accepts a String as a parameter
/**
* This method shares text and allows the user to select which app they would like to use to
* share the text. Using ShareCompat's IntentBuilder, we get some really cool functionality for
* free. The chooser that is started using the {@link IntentBuilder#startChooser()} method will
* create a chooser when more than one app on the device can handle the Intent. This happens
* when the user has, for example, both a texting app and an email app. If only one Activity
* on the phone can handle the Intent, it will automatically be launched.
*
* @param textToShare Text that will be shared
*/
// @@1
private void shareText(String textToShare) {
// COMPLETED (2) Create a String variable called mimeType and set it to "text/plain"
/*
* You can think of MIME types similarly to file extensions. They aren't the exact same,
* but MIME types help a computer determine which applications can open which content. For
* example, if you double click on a .pdf file, you will be presented with a list of
* programs that can open PDFs. Specifying the MIME type as text/plain has a similar affect
* on our implicit Intent. With text/plain specified, all apps that can handle text content
* in some way will be offered when we call startActivity on this particular Intent.
*/
String mimeType = "text/plain";
// COMPLETED (3) Create a title for the chooser window that will pop up
/* This is just the title of the window that will pop up when we call startActivity */
String title = "Learning How to Share";
// COMPLETED (4) Use ShareCompat.IntentBuilder to build the Intent and start the chooser
/* ShareCompat.IntentBuilder provides a fluent API for creating Intents */
ShareCompat.IntentBuilder
/* The from method specifies the Context from which this share is coming from */
.from(this)
.setType(mimeType)
.setChooserTitle(title)
.setText(textToShare)
.startChooser();
}
}## Steps
1. Create a helper function to format the intent with mime type
2. Call the above function and pass it data to be shared