Java 尝试调用虚拟方法'；作废android.support.v7.app.MediaRouteActionProvider.setRouteSelector

我要走了

尝试调用虚拟方法“void” android.support.v7.app.MediaRouteActionProvider.setRouteSelector（android.support.v7.media.MediaRouteSelector）' 关于空对象引用

当我想为我的应用程序添加cast支持时，我已经在一个单独的项目中创建了所有内容，现在我只想将所有内容转移到我的应用程序中，我得到了这个例外。我不知道我在哪里犯了错误。 这是我的密码：

 ......

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


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        //for transaltion

        SharedPreferences LengPref = getSharedPreferences("language",
                MODE_PRIVATE);
        String langStr = LengPref.getString("lang", "");

        String languageToLoad = langStr;
        Locale locale = new Locale(languageToLoad);
        Locale.setDefault(locale);
        Configuration config = new Configuration();
        config.locale = locale;
        getBaseContext().getResources().updateConfiguration(config, null);
        // for transaltion
        super.onCreate(savedInstanceState);




        // 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();




       .....
    }




    private class MyMediaRouterCallback extends MediaRouter.Callback {

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

            launchReceiver();
        }

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


   .......

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu items for use in the action bar
        MenuInflater inflater = getMenuInflater();

        //getMenuInflater().inflate(R.menu.main, menu);


        if (workoutTypeFinal == 0) {
            inflater.inflate(R.menu.workout_menu, menu);


        } else if (workoutTypeFinal == 2 || workoutTypeFinal == 3) {
            inflater.inflate(R.menu.workout_menu, menu);
        } else {
            //ovo je ako je next next tip
            inflater.inflate(R.menu.workout_menu_2, 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);

        mOptionsMenu = menu;
        return super.onCreateOptionsMenu(menu);
    }

    .....
    @Override
    protected void onStop() {
        mMediaRouter.removeCallback(mMediaRouterCallback);
        super.onStop();

        if (hasTimer == true) {
            timer5.cancel();
            timer2.cancel();
        }

        if (workoutTypeFinal == 0) {
            //inflater.inflate(R.menu.workout_menu, menu);
            if (isTimer1 == true) {
                timer1.cancel();
                //timer5.cancel();
                //mp.stop();
            } else if (isTimer2 == true) {
                timer2.cancel();
                timer5.cancel();
                if (isMusic == true) {
                    mp.stop();
                } else {

                }
            } else if (isTimer3 == true) {
                timer3.cancel();
                timer5.cancel();
                mp.stop();
            } else if (isTimer4 == true) {
                timer4.cancel();
                timer5.cancel();
                mp.stop();
            }
        } else if (workoutTypeFinal == 2) {
            //inflater.inflate(R.menu.workout_menu, menu);


        } else {
            //ovo je ako je next next tip
            //inflater.inflate(R.menu.workout_menu_2, menu);
        }


    }

    @Override
    protected void onPause() {
        super.onPause();
        //pausedVoid=false;


        if (workoutTypeFinal == 0) {
            if (pausedVoid == true) {

            } else {
                pauseTime();
            }

        } else if (workoutTypeFinal == 2) {
            if (pausedVoid == true) {

            } else {
                pauseTime();
            }

            //asd

        } else {
            //ovo je ako je next next tip

        }


    }

    @Override
    protected void onDestroy() {
        teardown(true);
        super.onDestroy();
        if (hasTimer == true) {
            timer5.cancel();
            timer2.cancel();
        }

        if (workoutTypeFinal == 0) {
            //inflater.inflate(R.menu.workout_menu, menu);
            if (isTimer1 == true) {
                timer1.cancel();
                //timer5.cancel();
                //mp.stop();
            } else if (isTimer2 == true) {
                timer2.cancel();
                timer5.cancel();
                if (isMusic == true) {
                    mp.stop();
                } else {

                }
            } else if (isTimer3 == true) {
                timer3.cancel();
                timer5.cancel();
                mp.stop();
            } else if (isTimer4 == true) {
                timer4.cancel();
                timer5.cancel();
                mp.stop();
            }
        } else if (workoutTypeFinal == 2) {
            //inflater.inflate(R.menu.workout_menu, menu);
            if (isTimer1 == true) {
                timer1.cancel();
                //timer5.cancel();
                //mp.stop();
            } else if (isTimer2 == true) {
                timer2.cancel();
                timer5.cancel();
                if (isMusic == true) {
                    mp.stop();
                } else {

                }
            } else if (isTimer3 == true) {
                timer3.cancel();
                timer5.cancel();
                mp.stop();
            } else if (isTimer4 == true) {
                timer4.cancel();
                timer5.cancel();
                mp.stop();
            }

        } else {
            //ovo je ako je next next tip

        }

    }

    @Override
    protected void onResume() {
        super.onResume();

    }


    ........

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


    //Chromecast
    /**
     * 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(true);
                }

            };
            // 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(true);
                    } else {
                        // Re-create the custom message channel
                        try {
                            Cast.CastApi.setMessageReceivedCallbacks(
                                    mApiClient,
                                    mHelloWorldChannel.get_messageBus_round(),
                                    mHelloWorldChannel);

                            Cast.CastApi.setMessageReceivedCallbacks(
                                    mApiClient,
                                    mHelloWorldChannel.get_messageBus_current_text(),
                                    mHelloWorldChannel);
                            Cast.CastApi.setMessageReceivedCallbacks(
                                    mApiClient,
                                    mHelloWorldChannel.get_messageBus_current_exercise(),
                                    mHelloWorldChannel);
                            Cast.CastApi.setMessageReceivedCallbacks(
                                    mApiClient,
                                    mHelloWorldChannel.get_messageBus_current_time(),
                                    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(
                                                Cast.ApplicationConnectionResult result) {
                                            Status status = result.getStatus();
                                            Log.d(TAG,
                                                    "ApplicationConnectionResultCallback.onResult:"
                                                            + 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.get_messageBus_round(),
                                                            mHelloWorldChannel);

                                                    Cast.CastApi.setMessageReceivedCallbacks(
                                                            mApiClient,
                                                            mHelloWorldChannel.get_messageBus_current_text(),
                                                            mHelloWorldChannel);
                                                    Cast.CastApi.setMessageReceivedCallbacks(
                                                            mApiClient,
                                                            mHelloWorldChannel.get_messageBus_current_exercise(),
                                                            mHelloWorldChannel);
                                                    Cast.CastApi.setMessageReceivedCallbacks(
                                                            mApiClient,
                                                            mHelloWorldChannel.get_messageBus_current_time(),
                                                            mHelloWorldChannel);
                                                } catch (IOException e) {
                                                    Log.e(TAG, "Exception while creating channel",
                                                            e);
                                                }

                                                // set the initial instructions
                                                // on the receiver

                                                //Salje Talk to me text
                                                //sendMessage(getString(R.string.instructions),0);

                                            } else {
                                                Log.e(TAG, "application could not launch");
                                                teardown(true);
                                            }
                                        }
                                    });
                }
            } 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(false);
        }
    }

    /**
     * Tear down the connection to the receiver
     */
    private void teardown(boolean selectDefaultRoute) {
        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.get_messageBus_round());
                            Cast.CastApi.removeMessageReceivedCallbacks(
                                    mApiClient,
                                    mHelloWorldChannel.get_messageBus_current_text());
                            Cast.CastApi.removeMessageReceivedCallbacks(
                                    mApiClient,
                                    mHelloWorldChannel.get_messageBus_current_exercise());
                            Cast.CastApi.removeMessageReceivedCallbacks(
                                    mApiClient,
                                    mHelloWorldChannel.get_messageBus_current_time());

                            mHelloWorldChannel = null;
                        }
                    } catch (IOException e) {
                        Log.e(TAG, "Exception while removing channel", e);
                    }
                    mApiClient.disconnect();
                }
                mApplicationStarted = false;
            }
            mApiClient = null;
        }
        if (selectDefaultRoute) {
            mMediaRouter.selectRoute(mMediaRouter.getDefaultRoute());
        }
        mSelectedDevice = null;
        mWaitingForReconnect = false;
        mSessionId = null;
    }

    /**
     * Send a text message to the receiver
     */

    private void sendMessage(String message,int case_) {



        if (mApiClient != null && mHelloWorldChannel != null) {
            try {
                //Salje stranici message od text speacha
                if(case_ == 0){
                    Cast.CastApi.sendMessage(mApiClient, mHelloWorldChannel.get_messageBus_round(), message).setResultCallback(
                            new ResultCallback<Status>() {
                                @Override
                                public void onResult(Status result) {
                                    if (!result.isSuccess()) {
                                        Log.e(TAG, "Sending message failed");
                                    }
                                }
                            });
                }else if(case_ == 1){
                    Cast.CastApi.sendMessage(mApiClient, mHelloWorldChannel.get_messageBus_current_text(), message).setResultCallback(
                            new ResultCallback<Status>() {
                                @Override
                                public void onResult(Status result) {
                                    if (!result.isSuccess()) {
                                        Log.e(TAG, "Sending message failed");
                                    }
                                }
                            });
                }else if(case_ == 2){
                    Cast.CastApi.sendMessage(mApiClient, mHelloWorldChannel.get_messageBus_current_exercise(), message).setResultCallback(
                            new ResultCallback<Status>() {
                                @Override
                                public void onResult(Status result) {
                                    if (!result.isSuccess()) {
                                        Log.e(TAG, "Sending message failed");
                                    }
                                }
                            });
                }else if(case_ == 3){
                    Cast.CastApi.sendMessage(mApiClient, mHelloWorldChannel.get_messageBus_current_time(), 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 Cast.MessageReceivedCallback {

        /**
         * @return custom namespace
         */


        public String get_messageBus_round(){
            return getString(R.string.messageBus_round);
        }
        public String get_messageBus_current_text(){
            return getString(R.string.messageBus_current_text);
        }
        public String get_messageBus_current_exercise(){
            return getString(R.string.messageBus_current_exercise);
        }
        public String get_messageBus_current_time(){
            return getString(R.string.messageBus_current_time);
        }

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

    }

}

。。。。。。
专用媒体路由器；
专用媒体路由选择器mMediaRouteSelector；
私有MediaRouter.回调mMediaRouterCallback；
专用设备mSelectedDevice；
私有GoogleAppClient客户端；
private Cast.Listener mCastListener；
private GoogleAppClient.ConnectionCallbacks McConnectionCallbacks；
专用连接FailedListener McConnectionFailedListener；
私人HelloWorldChannel mHelloWorldChannel；
私有布尔映射已启动；
私有布尔M等待重新连接；
私有字符串mSessionId；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
//交易
SharedReferences LengPref=GetSharedReferences（“语言”，
模式(私人),；
字符串langStr=LengPref.getString（“lang”，即“”）；
字符串语言toload=langStr；
语言环境=新的语言环境（languageToLoad）；
setDefault（Locale）；
配置配置=新配置（）；
config.locale=locale；
getBaseContext（）.getResources（）.updateConfiguration（配置，null）；
//交易
super.onCreate（savedInstanceState）；
//配置强制转换设备发现
mMediaRouter=MediaRouter.getInstance（getApplicationContext（））；
mMediaRouteSelector=new MediaRouteSelector.Builder（）
.addControlCategory（CastMediaControlIntent.categoryForCast（getResources（））
.getString（R.string.app_id））.build（）；
mMediaRouterCallback=新的MyMediaRouterCallback（）；
.....
}
私有类MyMediaRouterCallback扩展了MediaRouter.Callback{
@凌驾
已选择路由上的公共无效（MediaRouter路由器、MediaRouter.RouteInfo信息）{
//Log.d（标记“onRouteSelected”）；
//处理用户路由选择。
mSelectedDevice=CastDevice.getFromBundle（info.getExtras（））；
启动接收器（）；
}
@凌驾
已选择路由上的公共无效（MediaRouter路由器、MediaRouter.RouteInfo信息）{
//Log.d（标记“onRouteUnselected:info=“+info”）；
撕裂（假）；
mSelectedDevice=null；
}
}
.......
@凌驾
公共布尔onCreateOptions菜单（菜单）{
//为菜单项充气，以便在操作栏中使用
MenuInflater充气机=getMenuInflater（）；
//getMenuInflater（）.充气（R.menu.main，menu）；
如果（workoutTypeFinal==0）{
充气机。充气（右菜单。训练菜单，菜单）；
}否则如果（workoutTypeFinal==2 | | workoutTypeFinal==3）{
充气机。充气（右菜单。训练菜单，菜单）；
}否则{
//下一个提示
充气机。充气（右菜单。训练菜单2，菜单）；
}
MenuItem mediaRouteMenuItem=menu.findItem（R.id.media\u route\u菜单项）；
MediaRouteActionProvider MediaRouteActionProvider
=（MediaRouteActionProvider）菜单项兼容
.getActionProvider（mediaRouteMenuItem）；
//为设备发现设置MediaRouteActionProvider选择器。
mediaRouteActionProvider.setRouteSelector（mMediaRouteSelector）；
mOptionsMenu=菜单；
返回super.onCreateOptions菜单（菜单）；
}
.....
@凌驾
受保护的void onStop（）{
mMediaRouter.removeCallback（mMediaRouterCallback）；
super.onStop（）；
如果（Hastinmer==true）{
timer5.cancel（）；
timer2.cancel（）；
}
如果（workoutTypeFinal==0）{
//充气机。充气（右菜单。训练菜单，菜单）；
if（isTimer1==true）{
timer1.cancel（）；
//timer5.cancel（）；
//mp.stop（）；
}else if（isTimer2==true）{
timer2.cancel（）；
timer5.cancel（）；
如果（isMusic==true）{
mp.stop（）；
}否则{
}
}else if（isTimer3==true）{
timer3.cancel（）；
timer5.cancel（）；
mp.stop（）；
}else if（isTimer4==true）{
timer4.cancel（）；
timer5.cancel（）；
mp.stop（）；
}
}否则如果（workoutTypeFinal==2）{
//充气机。充气（右菜单。训练菜单，菜单）；
}否则{
//下一个提示
//充气机。充气（右菜单。训练菜单2，菜单）；
}
}
@凌驾
受保护的void onPause（）{
super.onPause（）；
//pausedVoid=false；
如果（workoutTypeFinal==0）{
if（pausedVoid==true）{
}否则{
暂停时间（）；
}
}否则如果（workoutTypeFinal==2）{
if（pausedVoid==true）{
}否则{
暂停时间（）；
}
//自闭症
}否则{
//下一个提示
}
}
@凌驾
受保护的空onDestroy（）{
撕裂（真）；
super.ondestory（）；
如果（Hastinmer==true）{
timer5.cancel（）；
timer2.cancel（）；
}
如果（workoutTypeFinal==0）{
//充气机。充气（右菜单。训练菜单，菜单）；
if（isTimer1==true）{
timer1.cancel（）；
//timer5.cancel（）；
//mp.stop（）；
}e
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    tools:context="com.example.casthelloworld.MainActivity" >


    <item
        android:id="@+id/media_route_menu_item"
        android:title="@string/media_route_menu_title"
        app:actionProviderClass="android.support.v7.app.MediaRouteActionProvider"
        app:showAsAction="always"/>

</menu>