android4.2 RemoteDisplay远程显示修改为保存文件

最新推荐文章于 2024-10-30 11:07:18 发布
最新推荐文章于 2024-10-30 11:07:18 发布
阅读量390 收藏
点赞数
文章标签： 移动开发 java
原文链接：http://www.cnblogs.com/pengxinglove/p/5550933.html
版权
RemoteDisplay其是具体Display的业务实现，其包含JAVA层与JNI，library三个层。
在android 4.2当中主要是WifiDisplayAdapter使用了RemoteDisplay。

也就是RemoteDisplay其是基础，WifiDisplayAdapter只是使用了其的功能！！！

pizza\frameworks\base\media\java\android\media\RemoteDisplay.java

 

private native int nativeListen(String iface);
private native int nativeStartRecord(String iface);
private native int nativePauseRecord(int ptr);
private native int nativeResumeRecord(int ptr);
private native int nativeStopRecord(int ptr);
private native void nativeDispose(int ptr);

 

public static RemoteDisplay recordScreen(String outfile, Listener listener, Handler handler) {
     if (outfile == null) {
         throw new IllegalArgumentException("iface must not be null");
     }
     if (listener == null) {
         throw new IllegalArgumentException("listener must not be null");
     }
     if (handler == null) {
         throw new IllegalArgumentException("handler must not be null");
     }

     RemoteDisplay display = new RemoteDisplay(listener, handler);
     display.startRecording(outfile);
     return display;
}

 

    private void startListening(String iface) {
        mPtr = nativeListen(iface);
        if (mPtr == 0) {
            throw new IllegalStateException("Could not start listening for "
                    + "remote display connection on \"" + iface + "\"");
        }
        mGuard.open("dispose");
        mGuard.open("stopRecording");
    }
   public void startRecording(String outfile) {
        Log.e(TAG, "### startRecording ###");
                mPtr = nativeStartRecord(outfile);
        if (mPtr == 0) {
            throw new IllegalStateException("Could not start listening for "
                    + "remote display connection on \"" + outfile + "\"");
        }
    }

    public void pauseRecording() {
        Log.e(TAG, "### pauseRecording  ###");
        if(mPtr != 0)
            {      
                nativePauseRecord(mPtr);
            }
    }
    public void resumeRecording() {
        Log.e(TAG, "### resumeRecording  ###");
        if(mPtr != 0)
            {
                nativeResumeRecord(mPtr);
            }
    }

    public void stopRecording() {
        Log.e(TAG, "### stopRecording  ###");
     stopRecording(false);
    }

    private void stopRecording(boolean finalized) {
        if(mPtr != 0)
        {
            if (mGuardRecScr != null) {
                if (finalized) {
                    mGuardRecScr.warnIfOpen();
                } else {
                    mGuardRecScr.close();
                }
            }
              nativeStopRecord(mPtr);
        mPtr = 0;
        }
    }

// Called from native.
private void notifyRecordScreen(final byte[] buffer, final int len) {
        Log.e(TAG, "### notifyRecordScreen  ###");           
    mHandler.post(new Runnable() {
        @Override
        public void run() {
            mListener.onRecordScreen(buffer, len);
        }
    });
}

    /**
     * Listener invoked when the remote display connection changes state.
     */
    public interface Listener {
        void onDisplayConnected(Surface surface, int width, int height, int flags);
        void onDisplayDisconnected();
        void onDisplayError(int error);
       void onRecordScreen(byte[] buffer, int len);    
}

pizza\frameworks\base\core\jni\android_media_RemoteDisplay.cpp

namespace android {

static struct {
    jmethodID notifyDisplayConnected;
    jmethodID notifyDisplayDisconnected;
    jmethodID notifyDisplayError;
    jmethodID notifyRecordScreen;
} gRemoteDisplayClassInfo;

// ----------------------------------------------------------------------------

class NativeRemoteDisplayClient : public BnRemoteDisplayClient {
public:
    NativeRemoteDisplayClient(JNIEnv* env, jobject remoteDisplayObj) :
            mRemoteDisplayObjGlobal(env->NewGlobalRef(remoteDisplayObj)) {
    }

protected:
    ~NativeRemoteDisplayClient() {
        JNIEnv* env = AndroidRuntime::getJNIEnv();
        env->DeleteGlobalRef(mRemoteDisplayObjGlobal);
    }

public:
    virtual void onDisplayConnected(const sp<ISurfaceTexture>& surfaceTexture,
            uint32_t width, uint32_t height, uint32_t flags) {
        JNIEnv* env = AndroidRuntime::getJNIEnv();

        jobject surfaceObj = android_view_Surface_createFromISurfaceTexture(env, surfaceTexture);
        if (surfaceObj == NULL) {
            ALOGE("Could not create Surface from surface texture %p provided by media server.",
                    surfaceTexture.get());
            return;
        }

        env->CallVoidMethod(mRemoteDisplayObjGlobal,
                gRemoteDisplayClassInfo.notifyDisplayConnected,
                surfaceObj, width, height, flags);
        env->DeleteLocalRef(surfaceObj);
        checkAndClearExceptionFromCallback(env, "notifyDisplayConnected");
    }

    virtual void onDisplayDisconnected() {
        JNIEnv* env = AndroidRuntime::getJNIEnv();

        env->CallVoidMethod(mRemoteDisplayObjGlobal,
                gRemoteDisplayClassInfo.notifyDisplayDisconnected);
        checkAndClearExceptionFromCallback(env, "notifyDisplayDisconnected");
    }

    virtual void onDisplayError(int32_t error) {
        JNIEnv* env = AndroidRuntime::getJNIEnv();

        env->CallVoidMethod(mRemoteDisplayObjGlobal,
                gRemoteDisplayClassInfo.notifyDisplayError, error);
        checkAndClearExceptionFromCallback(env, "notifyDisplayError");
    }

  virtual void onRecordScreen(char *buffer, int len) {
    }

private:
    jobject mRemoteDisplayObjGlobal;

    static void checkAndClearExceptionFromCallback(JNIEnv* env, const char* methodName) {
        if (env->ExceptionCheck()) {
            ALOGE("An exception was thrown by callback '%s'.", methodName);
            LOGE_EX(env);
            env->ExceptionClear();
        }
    }
};

class NativeRemoteDisplay {
public:
    NativeRemoteDisplay(const sp<IRemoteDisplay>& display,
            const sp<NativeRemoteDisplayClient>& client) :
            mDisplay(display), mClient(client) {
    }

    ~NativeRemoteDisplay() {
        mDisplay->dispose();
    }

private:
    sp<IRemoteDisplay> mDisplay;
    sp<NativeRemoteDisplayClient> mClient;
};

// ----------------------------------------------------------------------------

struct RemoteDisplayClient : public BnRemoteDisplayClient {
    RemoteDisplayClient(JNIEnv* env, jobject remoteDisplayObj);

    virtual void onDisplayConnected(
            const sp<ISurfaceTexture> &surfaceTexture,
            uint32_t width,
            uint32_t height,
            uint32_t flags);

    virtual void onDisplayDisconnected();
    virtual void onDisplayError(int32_t error);
    virtual void onRecordScreen(char *buffer, int len);

    void waitUntilDone();

protected:
    virtual ~RemoteDisplayClient();

private:
    JNIEnv* mEnv;

    Mutex mLock;
    Condition mCondition;

    bool mDone;

// 有了这个几个Display才能够真正的镜像显示数据

    sp<SurfaceComposerClient> mComposerClient;
    sp<ISurfaceTexture> mSurfaceTexture;
    sp<IBinder> mDisplayBinder;

    jobject mRemoteDisplayObjGlobal;
    static void checkAndClearExceptionFromCallback(JNIEnv* env, const char* methodName) {
        if (env->ExceptionCheck()) {
            ALOGE("An exception was thrown by callback '%s'.", methodName);
            LOGE_EX(env);
            env->ExceptionClear();
        }
    }

    DISALLOW_EVIL_CONSTRUCTORS(RemoteDisplayClient);
};

static status_t enableAudioSubmix(bool enable) {
    status_t err = AudioSystem::setDeviceConnectionState(
            AUDIO_DEVICE_IN_REMOTE_SUBMIX,
            enable
                ? AUDIO_POLICY_DEVICE_STATE_AVAILABLE
                : AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
            NULL /* device_address */);

    if (err != OK) {
    return err;
}

    err = AudioSystem::setDeviceConnectionState(
            AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
            enable
                ? AUDIO_POLICY_DEVICE_STATE_AVAILABLE
                : AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
            NULL /* device_address */);

    return err;
}

RemoteDisplayClient::RemoteDisplayClient(JNIEnv* env, jobject remoteDisplayObj) :
         mEnv(env),
            mRemoteDisplayObjGlobal(env->NewGlobalRef(remoteDisplayObj)),
         mDone(false) {
    mComposerClient = new SurfaceComposerClient;
    mComposerClient->initCheck();
    //CHECK_EQ(mComposerClient->initCheck(), (status_t)OK);
}

RemoteDisplayClient::~RemoteDisplayClient() {
            JNIEnv* env = AndroidRuntime::getJNIEnv();
        env->DeleteGlobalRef(mRemoteDisplayObjGlobal);
}

void RemoteDisplayClient::onDisplayConnected(
        const sp<ISurfaceTexture> &surfaceTexture,
        uint32_t width,
        uint32_t height,
        uint32_t flags) {
    ALOGI("#### onDisplayConnected width=%u, height=%u, flags = 0x%08x",
          width, height, flags);
    if(999 == flags)
    {
        onRecordScreen((char *)width, (int)height);
    return;
    }   
    mSurfaceTexture = surfaceTexture;

// 内部通过SurfaceComposerClient,最终调用SurfaceFlinger来创建一个DisplayDeviceState,添加到

// DisplayDeviceState info(DisplayDevice::DISPLAY_VIRTUAL); –> 所有createDisplay均是DISPLAY_VIRTUAL类型

//mCurrentState.displays.add(token,info); 在SurfaceFlinger当中添加了一个显示设备，SurfaceFlinger就会将这些数据

// 写到这些显示设备上面
    mDisplayBinder = mComposerClient->createDisplay(
            String8("foo"), false /* secure */);

    SurfaceComposerClient::openGlobalTransaction();

// 修改内部DisplayState  定义在LayerState.h当中

// DisplayState &s(getDisplayStateLocked(token));

//s.surface = bufferProducer;

//s.what |= DisplayState::eSurfaceChanged;


    mComposerClient->setDisplaySurface(mDisplayBinder, mSurfaceTexture);

    //Rect layerStackRect(1280, 720);  // XXX fix this.
    Rect layerStackRect(width, height);  // XXX fix this.
    //Rect displayRect(1280, 720);
    Rect displayRect(width, height);

    mComposerClient->setDisplayProjection(
            mDisplayBinder, 0 /* 0 degree rotation */,
            layerStackRect,
            displayRect);

    SurfaceComposerClient::closeGlobalTransaction();
}

void RemoteDisplayClient::onDisplayDisconnected() {

    enableAudioSubmix(false /* enable */);
    //Mutex::Autolock autoLock(mLock);
    //mDone = true;
    ALOGD("onDisplayDisconnected");
    //mCondition.broadcast();
}

void RemoteDisplayClient::onDisplayError(int32_t error) {
    ALOGI("onDisplayError error=%d", error);

    Mutex::Autolock autoLock(mLock);
    mDone = true;
    mCondition.broadcast();
}

void RemoteDisplayClient::onRecordScreen(char *buffer, int len) {
    //JNIEnv* env = AndroidRuntime::getJNIEnv();
    JNIEnv* env = mEnv;
       jbyteArray data =  env->NewByteArray(len);
       env->SetByteArrayRegion(data, 0, len,
           reinterpret_cast<const jbyte*>(buffer));

    ALOGE("### onRecordScreen in android_media_RemoteDisplay.cpp ###");
       env->CallVoidMethod(mRemoteDisplayObjGlobal,
                gRemoteDisplayClassInfo.notifyRecordScreen, data, len);
       checkAndClearExceptionFromCallback(env, "notifyRecordScreen");
}

void RemoteDisplayClient::waitUntilDone() {
    Mutex::Autolock autoLock(mLock);
    while (!mDone) {
        mCondition.wait(mLock);
    }
}

class NativeRemoteDisplayEx {
public:
    NativeRemoteDisplayEx(const sp<IRemoteDisplay>& display,
            const sp<RemoteDisplayClient>& client) :
            mDisplay(display), mClient(client) {
    }

    ~NativeRemoteDisplayEx()
    {
    ALOGI("### ~NativeRemoteDisplayEx 01 ###");
        if(mDisplay != NULL)
        {
    ALOGI("### ~NativeRemoteDisplayEx 02 ###");
               mDisplay->dispose();
        }
        }

     void pauseRecord()
    {
    ALOGI("### pauseRecord 01 ###");
        if(mDisplay != NULL)
        {
    ALOGI("### pauseRecord 02 ###");
            mDisplay->pause();
        }
        }

     void resumeRecord()
    {
    ALOGI("### resumeRecord 01 ###");   
        if(mDisplay != NULL)
        {
    ALOGI("### resumeRecord 02 ###");   
                mDisplay->resume();
        }
        }

     void stopRecord()
    {
    ALOGI("### stopRecord 01 ###");   
        if(mDisplay != NULL)
        {
    ALOGI("### stopRecord 02 ###");   
                mDisplay->dispose();
        }
        }

private:
    sp<IRemoteDisplay> mDisplay;
    sp<RemoteDisplayClient> mClient;
};

static jint nativeStartRecord(JNIEnv* env, jobject remoteDisplayObj, jstring ifaceStr) {
    ScopedUtfChars iface(env, ifaceStr);
    ALOGI("### nativeStartRecord ###");
    sp<IServiceManager> sm = defaultServiceManager();
    sp<IBinder> binder = sm->getService(String16("media.player"));
    sp<IMediaPlayerService> service =
        interface_cast<IMediaPlayerService>(binder);

    CHECK(service.get() != NULL);

    enableAudioSubmix(true /* enable */);

    sp<RemoteDisplayClient> client = new RemoteDisplayClient(env, remoteDisplayObj);
    sp<IRemoteDisplay> display = service->listenForRemoteDisplay(client, String8(iface.c_str()));

#if 0 //{
    if(wrapper != NULL)
    {
        //delete wrapper;
        //wrapper = NULL;
    }
#endif //}   
      NativeRemoteDisplayEx* wrapper = new NativeRemoteDisplayEx(display, client);

    return reinterpret_cast<jint>(wrapper);
}

static jint nativePauseRecord(JNIEnv* env, jobject remoteDisplayObj, jint ptr) {
    ALOGI("### nativePauseRecord ###");
  NativeRemoteDisplayEx* wrapper = reinterpret_cast<NativeRemoteDisplayEx*>(ptr);
  wrapper->pauseRecord();
    return 0;
}

static jint nativeResumeRecord(JNIEnv* env, jobject remoteDisplayObj, jint ptr) {
    ALOGI("### nativeResumeRecord ###");
  NativeRemoteDisplayEx* wrapper = reinterpret_cast<NativeRemoteDisplayEx*>(ptr);
  wrapper->resumeRecord(); 
    return 0;
}

static jint nativeStopRecord(JNIEnv* env, jobject remoteDisplayObj, jint ptr) {
    ALOGI("### nativeStopRecord ###");
  NativeRemoteDisplayEx* wrapper = reinterpret_cast<NativeRemoteDisplayEx*>(ptr);  
    delete wrapper;
    //wrapper->stopRecord();
    return 0;
}

static jint nativeListen(JNIEnv* env, jobject remoteDisplayObj, jstring ifaceStr) {
    ScopedUtfChars iface(env, ifaceStr);

    sp<IServiceManager> sm = defaultServiceManager();
    sp<IMediaPlayerService> service = interface_cast<IMediaPlayerService>(
            sm->getService(String16("media.player")));
    if (service == NULL) {
        ALOGE("Could not obtain IMediaPlayerService from service manager");
        return 0;
    }

    sp<NativeRemoteDisplayClient> client(new NativeRemoteDisplayClient(env, remoteDisplayObj));
    sp<IRemoteDisplay> display = service->listenForRemoteDisplay(
            client, String8(iface.c_str()));
    if (display == NULL) {
        ALOGE("Media player service rejected request to listen for remote display '%s'.",
                iface.c_str());
        return 0;
    }

    NativeRemoteDisplay* wrapper = new NativeRemoteDisplay(display, client);
    return reinterpret_cast<jint>(wrapper);
}

static void nativeDispose(JNIEnv* env, jobject remoteDisplayObj, jint ptr) {
    NativeRemoteDisplay* wrapper = reinterpret_cast<NativeRemoteDisplay*>(ptr);
    delete wrapper;
}

// ----------------------------------------------------------------------------

static JNINativeMethod gMethods[] = {
    {"nativeListen", "(Ljava/lang/String;)I",
            (void*)nativeListen },
    {"nativeStartRecord", "(Ljava/lang/String;)I",
            (void*)nativeStartRecord },
    {"nativePauseRecord", "(I)I",
            (void*)nativePauseRecord },
    {"nativeResumeRecord", "(I)I",
            (void*)nativeResumeRecord },
    {"nativeStopRecord", "(I)I",
            (void*)nativeStopRecord },           
    {"nativeDispose", "(I)V",
            (void*)nativeDispose },
};

int register_android_media_RemoteDisplay(JNIEnv* env)
{
    int err = AndroidRuntime::registerNativeMethods(env, "android/media/RemoteDisplay",
            gMethods, NELEM(gMethods));

    jclass clazz = env->FindClass("android/media/RemoteDisplay");
    gRemoteDisplayClassInfo.notifyDisplayConnected =
            env->GetMethodID(clazz, "notifyDisplayConnected",
                    "(Landroid/view/Surface;III)V");
    gRemoteDisplayClassInfo.notifyDisplayDisconnected =
            env->GetMethodID(clazz, "notifyDisplayDisconnected", "()V");
    gRemoteDisplayClassInfo.notifyDisplayError =
            env->GetMethodID(clazz, "notifyDisplayError", "(I)V");
    gRemoteDisplayClassInfo.notifyRecordScreen =
            env->GetMethodID(clazz, "notifyRecordScreen", "([BI)V");   
    return err;
}

 

 

pizza\frameworks\base\core\java\android\hardware\display\IDisplayManager.aidl

  DisplayManager负责管理所有的Display对象，给JAVA用户负责使用的接口

// No permissions required.
void startScreenRecord(String outfile);

// No permissions required.
void pauseScreenRecord();

// No permissions required.
void resumeScreenRecord();

// No permissions required.
void stopScreenRecord();

// No permissions required.
boolean canRecordScreen();

// No permissions required.
boolean canUseWfd();

 
pizza\frameworks\base\services\java\com\android\server\display\DisplayManagerService.java

   public void startScreenRecord(String outfile) {
        final long token = Binder.clearCallingIdentity();
        try {
            synchronized (mSyncRoot) {
                if (mWifiDisplayAdapter != null) {
                    mWifiDisplayAdapter.requestStartRecordScreenLocked(outfile);
                }
            }
        } finally {
            Binder.restoreCallingIdentity(token);
        }
    }

    @Override // Binder call
    public void pauseScreenRecord() {
        final long token = Binder.clearCallingIdentity();
        try {
            synchronized (mSyncRoot) {
                if (mWifiDisplayAdapter != null) {
                    mWifiDisplayAdapter.requestPauseRecordScreenLocked();
                }
            }
        } finally {
            Binder.restoreCallingIdentity(token);
        }
    }
    @Override // Binder call
    public void resumeScreenRecord() {
        final long token = Binder.clearCallingIdentity();
        try {
            synchronized (mSyncRoot) {
                if (mWifiDisplayAdapter != null) {
                    mWifiDisplayAdapter.requestResumeRecordScreenLocked();
                }
            }
        } finally {
            Binder.restoreCallingIdentity(token);
        }
    }

    @Override // Binder call
    public void stopScreenRecord() {
        final long token = Binder.clearCallingIdentity();
        try {
            synchronized (mSyncRoot) {
                if (mWifiDisplayAdapter != null) {
                    mWifiDisplayAdapter.requestStopRecordScreenLocked();
                }
            }
        } finally {
            Binder.restoreCallingIdentity(token);
        }
    }

    @Override // Binder call
    public boolean canRecordScreen() {
        if (mWifiDisplayAdapter != null) {
            return mWifiDisplayAdapter.requestCanRecordScreenLocked();
        }
     return false;
    }

    @Override // Binder call
    public boolean canUseWfd() {
        if (mWifiDisplayAdapter != null) {
            return mWifiDisplayAdapter.requestCanUseWfdLocked();
        }
     return false;
    }

    @Override // Binder call

 

RemoteDisplay 其被有三个部分WifiDisplayAdapter，WifiDisplayController.java， WifiDisplayDevice集成起来使用。

 

pizza\frameworks\base\services\java\com\android\server\display\WifiDisplayAdapter.java

       public void requestStartRecordScreenLocked(final String outfile) {
        if (DEBUG) {
            Slog.d(TAG, "requestStartRecordScreenLocked");
        }

        getHandler().post(new Runnable() {
            @Override
            public void run() {
                if (mDisplayController != null) {
                    mDisplayController.requestStartRecordScreen(outfile);
                }
            }
        });
    }

       public void requestPauseRecordScreenLocked() {
        if (DEBUG) {
            Slog.d(TAG, "requestPauseRecordScreenLocked");
        }

        getHandler().post(new Runnable() {
            @Override
            public void run() {
                if (mDisplayController != null) {
                    mDisplayController.requestPauseRecordScreen();
                }
            }
        });
    }

       public void requestResumeRecordScreenLocked() {
        if (DEBUG) {
            Slog.d(TAG, "requestResumeRecordScreenLocked");
        }

        getHandler().post(new Runnable() {
            @Override
            public void run() {
                if (mDisplayController != null) {
                    mDisplayController.requestResumeRecordScreen();
                }
            }
        });
    }

       public void requestStopRecordScreenLocked() {
        if (DEBUG) {
            Slog.d(TAG, "requestStopRecordScreenLocked");
        }

        getHandler().post(new Runnable() {
            @Override
            public void run() {
                if (mDisplayController != null) {
                    mDisplayController.requestStopRecordScreen();
                }
            }
        });
    }

       public boolean requestCanRecordScreenLocked() {
                if (mDisplayController != null) {
                    return mDisplayController.requestCanRecordScreen();
                }
          return false;
    }

       public boolean requestCanUseWfdLocked() {
                if (mDisplayController != null) {
                    return mDisplayController.requestCanUseWfd();
                }
          return false;
    }

pizza\frameworks\base\services\java\com\android\server\display\WifiDisplayController.java

private static final int RECSCR_STATUS_UNKNOWN = -1;
private static final int RECSCR_STATUS_RECORDING = 1;
private static final int RECSCR_STATUS_PAUSED = 2;
private static final int RECSCR_STATUS_STOPPED = 3;   

private RemoteDisplay mRecordScreen;

    public void requestStartRecordScreen(String outfile) {
        if(RECSCR_STATUS_UNKNOWN == mRecordStatus || RECSCR_STATUS_STOPPED == mRecordStatus)
        {
            if(mRemoteDisplay != null)
            {
                Slog.e(TAG, "### requestStartRecordScreen mRemoteDisplay != null ###");
                return;
            }
            Slog.d(TAG, "### requestStartRecordScreen outfile: " + outfile + " ###");
                mRecordScreen = RemoteDisplay.recordScreen(outfile, new RemoteDisplay.Listener() {
                        @Override
                        public void onDisplayConnected(Surface surface,
                                int width, int height, int flags) {
                            Slog.d(TAG, "### onDisplayConnected ###");
                        }

                        @Override
                        public void onDisplayDisconnected() {
                               Slog.d(TAG, "### onDisplayDisconnected ###");
                        }

                        @Override
                        public void onDisplayError(int error) {
                            Slog.d(TAG, "### onDisplayError ###");                       
                        }

                        @Override
                        public void onRecordScreen(byte[] buffer, int len) {
                            Slog.d(TAG, "### onRecordScreen ###");
                        }
                    }, mHandler);
                mHandler.postDelayed(mRtspTimeout, RTSP_TIMEOUT_SECONDS * 1000  * 1000);
        mRecordStatus = RECSCR_STATUS_RECORDING;
        }
    }

    public void requestPauseRecordScreen() {
        if(RECSCR_STATUS_RECORDING == mRecordStatus && mRecordScreen != null)
        {
            Slog.d(TAG, "### requestPauseRecordScreen ###");
            mRecordScreen.pauseRecording();
            mRecordStatus = RECSCR_STATUS_PAUSED;
        }
    }

    public void requestResumeRecordScreen() {
        if(RECSCR_STATUS_PAUSED == mRecordStatus && mRecordScreen != null)
        {
            Slog.d(TAG, "### requestResumeRecordScreen ###");
            mRecordScreen.resumeRecording();
            mRecordStatus = RECSCR_STATUS_RECORDING;
        }
    }

    public void requestStopRecordScreen() {
        if(RECSCR_STATUS_RECORDING == mRecordStatus && mRecordScreen != null)
        {
            Slog.d(TAG, "### requestStopRecordScreen ###");
            mRecordScreen.stopRecording();
            mRecordStatus = RECSCR_STATUS_STOPPED;
            mRecordScreen = null;
        }       
    }

    public boolean requestCanRecordScreen() {
        Slog.d(TAG, "### requestCanRecordScreen ###");
        if(mRemoteDisplay == null)
        {
            Slog.d(TAG, "### requestCanRecordScreen true ###");
            return true;
        }
        return false;
    }

    public boolean requestCanUseWfd() {
        Slog.d(TAG, "### requestCanUseWfd ###");
        if(mRecordScreen == null)
        {
            Slog.d(TAG, "### requestCanUseWfd true ###");
            return true;
        }
        return false;
    }

转载于:https://www.cnblogs.com/pengxinglove/p/5550933.html

weixin_30449239
关注
第十七篇 --ANDROID DisplayManager 服务解析一
固弘的专栏
01-23 3万+
ANDROID从版本4.2开始提供了一个显示管理服务DisplayManagerService,支持多种显示类型的多个显示器的镜像显示，包括内建的显示类型（本地）、HDMI显示类型以及支持WIFI Display 协议( MIRACAST)，实现本地设备在远程显示器上的镜像显示。 整个架构类图如下： 显示管理服务通过DisplayManager提供对外接口，提供的接口包括如
Android 调试桥
Hedong的博客
01-12 4994
Android 调试桥 (adb) 是一个通用命令行工具，其允许您与模拟器实例或连接的 Android 设备进行通信。它可为各种设备操作提供便利，如安装和调试应用，并提供对 Unix shell（可用来在模拟器或连接的设备上运行各种命令）的访问。该工具作为一个客户端-服务器程序，包括三个组件： 客户端，该组件发送命令。客户端在开发计算机上运行。您可以通过发出 adb 命令从命令行终端调用客户
Remote Displayer for Android
01-02
ARD(Android Remote Displayer)可以通过电脑端软件(ADRHOST.exe)远程显示安卓系统智能手机和平板电脑的桌面。 支持根据分辨率自动缩放显示，支持原始大小显示及四分之一大小显示等四种缩放模式，支持屏幕自动旋转。 支持实时保存Android桌面到BMP文件、PNG文件和系统剪贴板(Clipboard)。 支持局域网内的自动侦测与连接，无需手动输入ADRHOST端的IP地址。 电脑端软件(ADRHOST.exe)支持快捷键操作，可实现全键盘控制。 目前仅支持网络连接的方式(WIFI、3G/4G)，暂不支持USB。 仅支持Android5.0及以上版本的系统，无需ROOT权限。 特别说明:由于android-5.1.0_r5之前的系统存在BUG，故在程序请求截取屏幕时不要勾选"不再显示"复选框， 否则程序在下次运行时会出现"系统界面"已停止运行的错误。该BUG的相关信息如下: android-5.1.0_r3 to android-5.1.0_r5 - Project: platform/frameworks/base 67676f8 : MediaProjectionPermissionActivity: Fix NPE. 应用场景:培训授课、产品演示、制作说明书等
Android Wi-Fi Display（Miracast）介绍
热门推荐
Innost的专栏
01-06 16万+
Android Wi-Fi Display（Miracast）介绍2012年11月中旬，Google发布了Android 4.2。虽然它和Android 4.1同属Jelly Bean系列，但却添加了很多新的功能。其中，在显示部分，Android 4.2在Project Butter基础上再接再厉，新增了对Wi-Fi Display功能的支持。由此也导致整个显示架构发生了较大的变化。本文首先介绍W
Remote Displayer for Android V1.2
weixin_33716941的博客
01-29 303
VERSION LOG for Android Remote Displayer Features:The app allows you to see your Android device remotely and capture the screen.Make sure your desktop and Android device is under the same WiFi netw...
android-cast-remote-display-sample：适用于Android的Google Cast的远程显示示例
02-03
Android的远程显示示例 Google Cast的Android远程显示示例 此示例演示如何使用称为“远程显示”的新Google Cast功能。 您的发件人应用现在可以直接渲染到任何Cast接收器，例如Chromecast。 接收器上的远程显示器可以呈现与发送器设备的显示器中呈现的信息完全不同的信息。 注意：要使其运行，您需要登录后必须获得的应用程序ID 抽象 在我们尝试寻找新的方式来吸引用户并促进他们共享其内容的方式，因此我们认为允许用户共享通过电视或其他屏幕找到的广告会很酷。 这样一来，夫妻，朋友和家人就可以讨论他们是否喜欢这些产品，而无需以简单的方式将其设备传递给彼此。 为了实现这一点，我们认为支持Cast的设备（例如将是一个不错的选择，这就是为什么我们在Android应用程序中实现了Google Cast的原因。 目前，我们只投放广告详细信息页面，全屏显示图片，并显示广告标题和价格。 关于 Adevinta在欧洲，拉丁美洲和北非的16个国家/地区运营数字市场。 我们领先的本地品牌包括法国的Leboncoin，西班牙的InfoJobs，意大利的Subito和匈牙利的Jo
CastRemoteDisplay-android:适用于 Android 的 Google Cast 远程显示 API 示例
06-03
CastRemoteDisplay-android 此 Google Cast 示例应用程序展示了如何使用远程显示 API。 依赖关系 来自 Android SDK 的 google-play-services_lib 库（至少版本 7.5.62） android-support-v7-appcompat（21 或以上版本） android-support-v7-mediarouter（20 或以上版本） 安装说明 查看来自 GitHub 的代码 使用 Google Cast SDK 开发人员控制台为远程显示接收器创建新的应用程序 ID： : 将应用 ID 添加到资源 strings.xml 文件中 在您的移动设备上运行该应用程序 单击“播放”按钮，选择 Google Cast 设备作为远程显示器 参考资料和如何报告错误 投射 API： : 设计清单： : 远程显示
Android 4.2 兼容性定义详解
详细规定了各种UI元素如**小部件**(Widgets)、**通知**(Notifications)、**搜索**(Search)、**吐司**(Toasts)、**主题**(Themes)、**动态壁纸**(Live Wallpapers)、**最近应用显示**(Recent Application Display)、*...
Android Binder进程间通信机制
2401_84520401的博客
04-28 851
a.transact ———进行一次Binder操作；b.queryLocalInterface——尝试获取本地Binder对象；c.
Android 逆向分析大全
墨鱼菜鸡
07-11 3513
转载：Android 逆向分析大全：https://www.jianshu.com/p/a12d04fc748f 1. 概述 1.1 分析步骤 通用逆向分析步骤 1. 了解该模块正向编程相关方法2. 使用apktool解密apk，得到资源、jni模块等文件3. 从apk提取出dex文件，使用dex2jar转换成jar文件，再用java逆向工具...
Remote display control
12-29
电脑与手机同步，手机可以通过电脑访问网络
ASRDisp.exe 移动设备同步显示软件 ActiveSync_Remote_Display
08-30
同步显示移动设备界面，可用鼠标键盘操作移动设备界面。
Android下WiFiDisplay功能探究
srw11的专栏
08-28 3万+
WiFiDisplay(WFD)是WiFi联盟在已有技术的基础上，为了加速视/音频的传输分享而提出来的一个新概念。随着Android4.2实现WiFiDisplay后，越来越多的移动设备都陆续IR实现了这一功能或是使用类似技术实现(DLNA，AirPlay)。
Miui+多屏协作--wifiDisplay-wireshark抓个包
Canok
06-12 1430
宣传了好久的mui12.5,终于在我的手机上推送了（RedmiK20Pro）,体验一下这个多屏协作功能。
vnc viewer连接闪退解决办法
weixin_34388207的博客
03-22 766
只需修改vnc option里面Advanced-->expert-->ColourLevel的值为“rgb222” or “full”即可。 说明：rgb111--8 colours，rgb222--64 colours，pal8 -- 256 colours，full -- full colours 转载于:https://blog.51ct...
Android 4.2wifidisplay采集
weixin_30588907的博客
08-12 283
Android 4.2wifidisplay采集 1. 显示设置display，其是最终显示的地方，其的数据格式，其的缓存结构 2. Display其的数据来源，又怎么样操作这些Display当中的数据如截个图，其与SurfaceFlinger有关系,在wifidisplay其的数据来源surfaceMediaSource 3. Android平板当中其是有多个显示设备，如平板的显示屏，HDMI,...
WFD抓包及视频提取
chanimei_11的博客
05-17 1578
一、手动抓取tcpdump数据包信息步骤如下： 1、使用USED版本，USB连接测试机和PC 2、adb root–》adb disable-verity–>重启手机–》重启后执行adb root–>adb remount 挂载成功–>adb shell 3、然后在adb shell中执行命令 tcpdump -i p2p0 -w sdcard/XXX自定义的文件名.cap 进行tcpdump数据包抓取不要断开，然后进行投屏操作 4、出现花屏后，导出手机里刚才抓取到的“XXX自定义的文..
Android 自定义背景渐变色
最新发布
Makenna's World
10-30 421
在上述代码中，我们通过setOrientation方法设置了渐变方向为从左到右。在上述代码中，我们设置了四种颜色进行渐变，即从红色到黄色再到绿色最后到蓝色。上述示例中我们只是使用了两种颜色进行渐变，而实际上，我们可以使用更多的颜色来实现更丰富的渐变效果。除了基本的渐变色效果，我们还可以实现一些高级的渐变效果，比如圆角渐变、渐变边框等。GradientDrawable.Orientation.TL_BR：从左上到右下。GradientDrawable.Orientation.BL_TR：从左下到右上。
Android流媒体播放远程mp3文件实现教程
本文将详细介绍如何在Android平台上实现流媒体播放远程MP3文件的功能。通过实例代码和步骤解析，我们将探讨Android系统中播放网络音频文件的关键技术和技巧。 在Android应用开发中，如果想要播放存储在远程服务器上...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值