Android Open Source - CastHelloText-android Main Activity

• Back to App/message  ↑

From Project

Back to project page CastHelloText-android.

License

The source code is released under:

Apache License

Java Source Code

/*
 * Copyright (C) 2014 Google Inc. All Rights Reserved. 
 */*  w  ww.  j  a  v  a2 s .com*/
 * 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.casthelloworld;

import java.io.IOException;
import java.util.ArrayList;

import android.content.Intent;
import android.graphics.drawable.ColorDrawable;
import android.os.Bundle;
import android.speech.RecognizerIntent;
import android.support.v4.view.MenuItemCompat;
import android.support.v7.app.ActionBar;
import android.support.v7.app.ActionBarActivity;
import android.support.v7.app.MediaRouteActionProvider;
import android.support.v7.media.MediaRouteSelector;
import android.support.v7.media.MediaRouter;
import android.support.v7.media.MediaRouter.RouteInfo;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;

import com.google.android.gms.cast.ApplicationMetadata;
import com.google.android.gms.cast.Cast;
import com.google.android.gms.cast.Cast.ApplicationConnectionResult;
import com.google.android.gms.cast.Cast.MessageReceivedCallback;
import com.google.android.gms.cast.CastDevice;
import com.google.android.gms.cast.CastMediaControlIntent;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.common.api.ResultCallback;
import com.google.android.gms.common.api.Status;

/**
 * Main activity to send messages to the receiver.
 */
public class MainActivity extends ActionBarActivity {

  private static final String TAG = MainActivity.class.getSimpleName();

  private static final int REQUEST_CODE = 1;

  private MediaRouter mMediaRouter;
  private MediaRouteSelector mMediaRouteSelector;
  private MediaRouter.Callback mMediaRouterCallback;
  private CastDevice mSelectedDevice;
  private GoogleApiClient mApiClient;
  private Cast.Listener mCastListener;
  private ConnectionCallbacks mConnectionCallbacks;
  private ConnectionFailedListener mConnectionFailedListener;
  private HelloWorldChannel mHelloWorldChannel;
  private boolean mApplicationStarted;
  private boolean mWaitingForReconnect;
  private String mSessionId;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    ActionBar actionBar = getSupportActionBar();
    actionBar.setBackgroundDrawable(new ColorDrawable(
        android.R.color.transparent));

    // When the user clicks on the button, use Android voice recognition to
    // get text
    Button voiceButton = (Button) findViewById(R.id.voiceButton);
    voiceButton.setOnClickListener(new OnClickListener() {
      @Override
      public void onClick(View v) {
        startVoiceRecognitionActivity();
      }
    });

    // Configure Cast device discovery
    mMediaRouter = MediaRouter.getInstance(getApplicationContext());
    mMediaRouteSelector = new MediaRouteSelector.Builder()
        .addControlCategory(
            CastMediaControlIntent.categoryForCast(getResources()
                .getString(R.string.app_id))).build();
    mMediaRouterCallback = new MyMediaRouterCallback();
  }

  /**
   * Android voice recognition
   */
  private void startVoiceRecognitionActivity() {
    Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
    intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
        RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
    intent.putExtra(RecognizerIntent.EXTRA_PROMPT,
        getString(R.string.message_to_cast));
    startActivityForResult(intent, REQUEST_CODE);
  }

  /*
   * Handle the voice recognition response
   * 
   * @see android.support.v4.app.FragmentActivity#onActivityResult(int, int,
   * android.content.Intent)
   */
  @Override
  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_CODE && resultCode == RESULT_OK) {
      ArrayList<String> matches = data
          .getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
      if (matches.size() > 0) {
        Log.d(TAG, matches.get(0));
        sendMessage(matches.get(0));
      }
    }
    super.onActivityResult(requestCode, resultCode, data);
  }

  @Override
  protected void onResume() {
    super.onResume();
    // Start media router discovery
    mMediaRouter.addCallback(mMediaRouteSelector, mMediaRouterCallback,
        MediaRouter.CALLBACK_FLAG_REQUEST_DISCOVERY);
  }

  @Override
  protected void onPause() {
    if (isFinishing()) {
      // End media router discovery
      mMediaRouter.removeCallback(mMediaRouterCallback);
    }
    super.onPause();
  }

  @Override
  public void onDestroy() {
    teardown();
    super.onDestroy();
  }

  @Override
  public boolean onCreateOptionsMenu(Menu menu) {
    super.onCreateOptionsMenu(menu);
    getMenuInflater().inflate(R.menu.main, menu);
    MenuItem mediaRouteMenuItem = menu.findItem(R.id.media_route_menu_item);
    MediaRouteActionProvider mediaRouteActionProvider = (MediaRouteActionProvider) MenuItemCompat
        .getActionProvider(mediaRouteMenuItem);
    // Set the MediaRouteActionProvider selector for device discovery.
    mediaRouteActionProvider.setRouteSelector(mMediaRouteSelector);
    return true;
  }

  /**
   * Callback for MediaRouter events
   */
  private class MyMediaRouterCallback extends MediaRouter.Callback {

    @Override
    public void onRouteSelected(MediaRouter router, RouteInfo info) {
      Log.d(TAG, "onRouteSelected");
      // Handle the user route selection.
      mSelectedDevice = CastDevice.getFromBundle(info.getExtras());

      launchReceiver();
    }

    @Override
    public void onRouteUnselected(MediaRouter router, RouteInfo info) {
      Log.d(TAG, "onRouteUnselected: info=" + info);
      teardown();
      mSelectedDevice = null;
    }
  }

  /**
   * Start the receiver app
   */
  private void launchReceiver() {
    try {
      mCastListener = new Cast.Listener() {

        @Override
        public void onApplicationDisconnected(int errorCode) {
          Log.d(TAG, "application has stopped");
          teardown();
        }

      };
      // Connect to Google Play services
      mConnectionCallbacks = new ConnectionCallbacks();
      mConnectionFailedListener = new ConnectionFailedListener();
      Cast.CastOptions.Builder apiOptionsBuilder = Cast.CastOptions
          .builder(mSelectedDevice, mCastListener);
      mApiClient = new GoogleApiClient.Builder(this)
          .addApi(Cast.API, apiOptionsBuilder.build())
          .addConnectionCallbacks(mConnectionCallbacks)
          .addOnConnectionFailedListener(mConnectionFailedListener)
          .build();

      mApiClient.connect();
    } catch (Exception e) {
      Log.e(TAG, "Failed launchReceiver", e);
    }
  }

  /**
   * Google Play services callbacks
   */
  private class ConnectionCallbacks implements
      GoogleApiClient.ConnectionCallbacks {
    @Override
    public void onConnected(Bundle connectionHint) {
      Log.d(TAG, "onConnected");

      if (mApiClient == null) {
        // We got disconnected while this runnable was pending
        // execution.
        return;
      }

      try {
        if (mWaitingForReconnect) {
          mWaitingForReconnect = false;

          // Check if the receiver app is still running
          if ((connectionHint != null)
              && connectionHint
                  .getBoolean(Cast.EXTRA_APP_NO_LONGER_RUNNING)) {
            Log.d(TAG, "App  is no longer running");
            teardown();
          } else {
            // Re-create the custom message channel
            try {
              Cast.CastApi.setMessageReceivedCallbacks(
                  mApiClient,
                  mHelloWorldChannel.getNamespace(),
                  mHelloWorldChannel);
            } catch (IOException e) {
              Log.e(TAG, "Exception while creating channel", e);
            }
          }
        } else {
          // Launch the receiver app
          Cast.CastApi
              .launchApplication(mApiClient,
                  getString(R.string.app_id), false)
              .setResultCallback(
                  new ResultCallback<Cast.ApplicationConnectionResult>() {
                    @Override
                    public void onResult(
                        ApplicationConnectionResult result) {
                      Status status = result.getStatus();
                      Log.d(TAG,
                          "ApplicationConnectionResultCallback.onResult: statusCode"
                              + status.getStatusCode());
                      if (status.isSuccess()) {
                        ApplicationMetadata applicationMetadata = result
                            .getApplicationMetadata();
                        mSessionId = result
                            .getSessionId();
                        String applicationStatus = result
                            .getApplicationStatus();
                        boolean wasLaunched = result
                            .getWasLaunched();
                        Log.d(TAG,
                            "application name: "
                                + applicationMetadata
                                    .getName()
                                + ", status: "
                                + applicationStatus
                                + ", sessionId: "
                                + mSessionId
                                + ", wasLaunched: "
                                + wasLaunched);
                        mApplicationStarted = true;

                        // Create the custom message
                        // channel
                        mHelloWorldChannel = new HelloWorldChannel();
                        try {
                          Cast.CastApi
                              .setMessageReceivedCallbacks(
                                  mApiClient,
                                  mHelloWorldChannel
                                      .getNamespace(),
                                  mHelloWorldChannel);
                        } catch (IOException e) {
                          Log.e(TAG,
                              "Exception while creating channel",
                              e);
                        }

                        // set the initial instructions
                        // on the receiver
                        sendMessage(getString(R.string.instructions));
                      } else {
                        Log.e(TAG,
                            "application could not launch");
                        teardown();
                      }
                    }
                  });
        }
      } catch (Exception e) {
        Log.e(TAG, "Failed to launch application", e);
      }
    }

    @Override
    public void onConnectionSuspended(int cause) {
      Log.d(TAG, "onConnectionSuspended");
      mWaitingForReconnect = true;
    }
  }

  /**
   * Google Play services callbacks
   */
  private class ConnectionFailedListener implements
      GoogleApiClient.OnConnectionFailedListener {
    @Override
    public void onConnectionFailed(ConnectionResult result) {
      Log.e(TAG, "onConnectionFailed ");

      teardown();
    }
  }

  /**
   * Tear down the connection to the receiver
   */
  private void teardown() {
    Log.d(TAG, "teardown");
    if (mApiClient != null) {
      if (mApplicationStarted) {
        if (mApiClient.isConnected()  || mApiClient.isConnecting()) {
          try {
            Cast.CastApi.stopApplication(mApiClient, mSessionId);
            if (mHelloWorldChannel != null) {
              Cast.CastApi.removeMessageReceivedCallbacks(
                  mApiClient,
                  mHelloWorldChannel.getNamespace());
              mHelloWorldChannel = null;
            }
          } catch (IOException e) {
            Log.e(TAG, "Exception while removing channel", e);
          }
          mApiClient.disconnect();
        }
        mApplicationStarted = false;
      }
      mApiClient = null;
    }
    mSelectedDevice = null;
    mWaitingForReconnect = false;
    mSessionId = null;
  }

  /**
   * Send a text message to the receiver
   * 
   * @param message
   */
  private void sendMessage(String message) {
    if (mApiClient != null && mHelloWorldChannel != null) {
      try {
        Cast.CastApi.sendMessage(mApiClient,
            mHelloWorldChannel.getNamespace(), message)
            .setResultCallback(new ResultCallback<Status>() {
              @Override
              public void onResult(Status result) {
                if (!result.isSuccess()) {
                  Log.e(TAG, "Sending message failed");
                }
              }
            });
      } catch (Exception e) {
        Log.e(TAG, "Exception while sending message", e);
      }
    } else {
      Toast.makeText(MainActivity.this, message, Toast.LENGTH_SHORT)
          .show();
    }
  }

  /**
   * Custom message channel
   */
  class HelloWorldChannel implements MessageReceivedCallback {

    /**
     * @return custom namespace
     */
    public String getNamespace() {
      return getString(R.string.namespace);
    }

    /*
     * Receive message from the receiver app
     */
    @Override
    public void onMessageReceived(CastDevice castDevice, String namespace,
        String message) {
      Log.d(TAG, "onMessageReceived: " + message);
    }

  }

}

Java Source Code List

• Back to App/message  ↑