Cannot call LoginFragment with a null calling package. This can occur if the launchMode of the caller is singleInstance.

 안드로이드 애플리케이션에 페이스북 로그인 연동을 하는 과정에서 다음과 같은 오류가 발생하였습니다.



 Cannot call LoginFragment with a null calling package. This can occur if the launchMode of the caller is singleInstance.


안드로이드 애플리케이션에서 제공되는 Facebook 로그인의 경우 로그인을 호출하는 Activity에서 다른 Activity를 호출할 때 single instance 방식으로 호출할 경우 로그인 창이 실행조차 되지 않는 상황이 발생합니다. single instance 방식은 안드로이드 애플리케이션 제작에 있어 최대한 지양하도록 공식적으로 가이드 되고 있으며 Facebook 로그인 라이브러리 또한 이를 준수하기 위해 single instance 방식의 호출을 막아둔 것으로 보입니다.


 이를 해결하기 위해 AndroidManifest.xml 파일을 열어 Facebook 로그인과 관련된 모든 <Activity >의 속성 안에


1
2
3
4
5
<activity 
    ....
    android:launchMode="standard"
    ....
</activity>
cs


 위와 같이 launch mode를 single instance에서 다른 것(standard 권장)으로 변경해주시면 로그인이 되는 것을 확인하실 수 있습니다.

안드로이드 6.0에서 SecurityException 처리방법(Call requires permission which may be rejected by user....)

 안드로이드 6.0버전(API-23)부터 애플리케이션을 설치할 때 권한을 묻지 않고 그대로 설치한 후 해당 앱을 실행하는 도중 특정한 권한이 필요하게 되었을 때 사용하고자 하는 권한을 묻는 방식으로 Permission을 설정하는 방식으로 변경되었습니다.



 이로 인해 안드로이드 6.0부터 애플리케이션을 제작할 때 특정 부분에서 Permission을 필요로 할 때 사용자에게 사용 여부를 묻는 방식으로 설계를 해야 합니다. 기존의 버전에서 처럼 제작을 하게 될 경우 아래와 같이 붉은 밑줄이 생기면서 설계자에게 경고를 합니다.



 기존의 방식대로면 전혀 문제가 될 일이 없습니다만 안드로이드 마시멜로에서 부터는 특정 권한을 필요로 하는 작업을 수행하기 위해 액세스를 하기 직전 권한 허용 여부를 확인하여야 이 에러를 해결할 수 있습니다.


1. try-catch로 SecurityException 처리하기

기존 코드를 그대로 사용할 경우 가장 간단한 방법으로 실행하고자 하는 소스코드 앞뒤로 try-catch Exception을 사용하는 방법입니다. 기존 코드를 완전히 뜯어고칠 필요 없이 try-catch를 추가하기 때문에 매우 간단합니다만 사용자가 Permission을 허가하지 않을 경우 이 코드를 실행하지 못하고 바로 Exception올 빠지게 됩니다.



2. checkSelfPermission()함수를 사용하여 권한여부 확인하기

 사용하고자 하는 Permission을 처리하기 전 사용자가 권한을 허가하였는지 미리 파악한 후 소스코드를 실행하는 방식입니다. try-catch로 SecurityException을 처리하는 것보다 좀 더 디테일하게 권한 사용 여부를 확인하며 만약 권한이 허가되지 않았을 경우 if-else문을 통해 사용자에게 다시 한 번 Permission을 허가해줄지 확인할 수 있도록 코딩할 수 있습니다.



 애플리케이션을 설치할 때 수두룩 나오는 Permission들이 어떤 부분에서 사용되는 지를 전혀 알길이 없어 바로 OK한 후 애플리케이션을 내려받아왔었는데 이번 6.0의 변화로 실행 도중에 어떤 상황에서 Permission이 사용되는지 좀 더 자세히 알 수 있어 쓸데없는 권한 사용을 남발하는 것을 줄일 수 있어 좋습니다. 다만, 이전처럼 한 번에 권한을 모두 갖는 것이 아니다 보니 실행 도중 Permission을 묻는 부분을 일일히 코딩해야 하는 것이 어렵다는건 아직까지는 적응이 되지 않습니다.

 무쪼록 앞으로도 안드로이드는 기존보다는 좀 더 나은 방향으로 발전할 것이라 기대해봅니다.

안드로이드 프레임워크 프로그래밍(28) [System Service의 proxy와 native의 Interface 상속 구조]

 안드로이드 프레임워크를 공부하는 데 있어 다루게 되는 내용 중 가장 중요한 것을 꼽아본다면 각 프로세스간의 통신 방식인 Binder의 활용이 아닐까 생각합니다. 실제로 안드로이드 운영체제 내에서 동작하는 System Service가 Android 애플리케이션 프로세스 상호간에 통신하기 위해서는 IPC(Interprocess Communication)통신의 일종인 Binder 통신을 사용합니다. 안드로이드 운영체제 또한 리눅스를 기반으로 만들어졌으므로 프로세스의 구조 또한 리눅스의 그것과 비슷하다고 할 수 있습니다. 다만, 기존 리눅스에서 사용하는 IPC 뿐 아니라 RPC(Remote Process Communication)를 사용해 AIDL(Android Interface Definition Language)를 통해 좀 더 간단하게 프로세스간 통신을 할 수 있게 하고 있습니다.



 위의 그램은 Application에서의 프로세스와 System Service에서의 프로세스가 Binder 드라이버를 통해 커널 상으로 통신하고 있는 모습을 그림으로 나타낸 것입니다. 본 포스팅에서는 위와 같은 Binder를 사용하기 위해 proxy와 native에서 Interface를 구성하는 과정에 대해 간단히 설명드리겠습니다. Android에서 proxy에 해당되는 프로세스는 앞부분에 bp를, native에 해당되는 프로세스는 bn을 붙여줍니다. 아마도 약자는 각각 binder proxy, binder native로 추정됩니다.


 먼저 System Service중 하나인 CameraService를 예를 들어 설명해 보겠습니다. 실제로 CameraService는 System Service의 일부로서 이를 사용하기 위해서는 Interface로 구성된 ICameraService를 통해 Binder를 통한 프로세스 통신을 해야 합니다.


/frameworks/av/include/camera/ICameraService.h

1
2
3
4
5
6
7
8
9
10
11
12
class ICameraService : public IInterface
{
public:
....
    virtual status_t connect(const sp<ICameraClient>& cameraClient,
            int cameraId,
            const String16& clientPackageName,
            int clientUid,
            /*out*/
            sp<ICamera>& device) = 0;
....
}
cs


 ICameraService 클래스는 IInterface 클래스를 상속받고 있으며 내부에는 virtual 함수 connect()가 있습니다. 차후 connect()함수는 ICameraService 클래스를 상속하는 클래스에서 정의될 것입니다.


/frameworks/native/include/binder/IInterface.h

1
2
3
4
5
6
7
8
9
10
11
class IInterface : public virtual RefBase
{
public:
            IInterface();
            static sp<IBinder>  asBinder(const IInterface*);
            static sp<IBinder>  asBinder(const sp<IInterface>&);
 
protected:
    virtual                     ~IInterface();
    virtual IBinder*            onAsBinder() = 0;
};
cs


 IInterface 클래스가 RefBase 클래스를 상속받고 


/frameworks/rs/cpp/util/RefBase.h

1
2
3
4
5
6
7
class RefBase
{
public:
 
...
 
}
cs


 RefBase 클래스는 안드로이드 native 단계에서의 framework 내에 있는 거의 대다수의 Class의 최상 부모입니다. 안드로이드에서는 이를 통해 각 클래스의 성질을 설정하고 있다고 생각해주시면 되겠습니다.


 그렇다면 위에서 설명해드렸던 ICameraService를 상속받는 클래스는 어떤 것이 있을까요? Application 프로세스가 System Service 프로세스와 통신하기 위해서는 총 2가지의 클래스를 사용하게 됩니다. Application 프로세스에서는 BpCameraService 클래스를, System Service 프로세스에서는 BnCameraService를 통해 Application 프로세스에서 요구하는 명령을 수행하게 됩니다.

 아래 소스코드는 ICameraService 클래스를 상속받는 BpCameraService의 모습을 나타냅니다.


/frameworks/av/camera/ICameraService.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class BpCameraService: public BpInterface<ICameraService>
{
public:
    BpCameraService(const sp<IBinder>& impl)
        : BpInterface<ICameraService>(impl)
    {
    }
....
    // connect to camera service (android.hardware.Camera)
    virtual status_t connect(const sp<ICameraClient>& cameraClient, int cameraId,
                             const String16 &clientPackageName, int clientUid,
                             /*out*/
                             sp<ICamera>& device)
    {
        Parcel data, reply;
        data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
        data.writeStrongBinder(cameraClient->asBinder());
        data.writeInt32(cameraId);
        data.writeString16(clientPackageName);
        data.writeInt32(clientUid);
        remote()->transact(BnCameraService::CONNECT, data, &reply);
 
        if (readExceptionCode(reply)) return -EPROTO;
        status_t status = reply.readInt32();
        if (reply.readInt32() != 0) {
            device = interface_cast<ICamera>(reply.readStrongBinder());
        }
        return status;
    }
....
}
cs

 소스코드를 보시면 아시듯이 BpCameraService는 BpInterface 클래스를 수식하는데 BpInterface 클래스는 ICameraService 클래스를 template로 설정하고 있는 것을 볼 수 있습니다. 그렇다면 BpInterface는 어떻게 생겼을까요? 


/frameworks/native/include/binder/IInterface.h
1
2
3
4
5
6
7
8
9
10
template<typename INTERFACE>
class BpInterface : public INTERFACEpublic BpRefBase
{
public:
                                BpInterface(const sp<IBinder>& remote);
 
protected:
    virtual IBinder*            onAsBinder();
};
 
cs

 놀랍게도 BpInterface는 template로 설저하였던 INTERFACE를 그대로 상속받는 것으로 설정하고 있습니다. 즉, 위의 경우 template인 INTERFACE는 ICameraService인 것이지요. 이렇게 BpInterface는 ICameraService와 BpRefBase 클래스를 다중상속 받고 있는 것입니다.

/frameworks/native/include/binder/Binder.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class BpRefBase : public virtual RefBase
{
protected:
                            BpRefBase(const sp<IBinder>& o);
    virtual                 ~BpRefBase();
    virtual void            onFirstRef();
    virtual void            onLastStrongRef(const void* id);
    virtual bool            onIncStrongAttempted(uint32_t flags, const void* id);
 
    inline  IBinder*        remote()                { return mRemote; }
    inline  IBinder*        remote() const          { return mRemote; }
 
private:
                            BpRefBase(const BpRefBase& o);
    BpRefBase&              operator=(const BpRefBase& o);
 
    IBinder* const          mRemote;
    RefBase::weakref_type*  mRefs;
    volatile int32_t        mState;
};
cs


 BpRefBase 클래스 또한 RefBase를 상속받고 있습니다. 결과적으로 BpCameraService는 RefBase를 다이아몬드 상속으로 두 번 이상 상속받고 있는 것입니다. 그 때문인지 RefBase는 virtual 클래스로 상속받는 것으로 이해할 수 있습니다.


 위에서 설명한 소스코드의 상속 구조도를 이미지로 표현하면 다음과 같습니다. native에서의 상속 구조도 나타내 보았으니 여러분들께서 BnCameraService를 직접 확인해보시면 원리를 파악하는데 큰 도움이 되실 겁니다. :)






안드로이드 프레임워크 프로그래밍(27) [Fedora에서 AOSP 안드로이드 운영체제 컴파일하기]

 일반적으로 안드로이드 운영체제를 Build 할 때 거의 대부분의 경우 Ubuntu 환경에서 수행됩니다. AOSP 공식 홈페이지에서도 Ubuntu를 권장하고 있는 바이기도 합니다.

 그래도 혹여나 하는 마음에 Fedora 운영체제에서 안드로이드를 Build 해보는 과정에 대해 포스팅을 해보고자 합니다. 같은 RPM 패키지를 사용하는 Redhat이나 OpenSUSE에서도 이 포스팅의 내용을 적용할 수 있으리라 생각합니다.


Build Version    : Android 6.0.1(Marshmellow)

OS             : Fedora 23 (Twenty Three) 64-bit

JDK Version     : OpenJDK 1.7.0


1. 빌드하고자 하는 AOSP 소스코드를 다운로드 받습니다. 관련 내용에 대해 자세히 알아보고자 하시는 분은 아래 포스팅을 참조해 주기길 바랍니다.

http://elecs.tistory.com/56


$ mkdir ~/bin

$ export PATH=$PATH:~/bin

$ curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo

$ chmod a+x ~/bin/reop

$ mkdir ~/aosp 

$ cd ~/aosp

$ repo init -u https://android.googlesource.com/platform/manifest -b android-6.0.1_r1

$ repo sync -j4


 위 과정까지 마치셨다면 아래와 같이 aosp 폴더에 소스코드 다운로드 된 것을 확인하실 수 있습니다.


2. 다운로드한 안드로이드 소스코드를 컴파일할 수 있는 환경을 설정합니다. Marshmellow(6.0) 버전의 경우 OpenJDK 1.7.0을 설치해야 합니다. Oracle JDK로 컴파일을 시도하려 해도 시작하기 전에 컴파일이 중단되어버립니다. Fedora의 경우 dnf를 통해서는 최신 버전의 자바만 지원해주기 때문에 사용자가 직접 OpenJDK를 설치해야 합니다. 설치 방법은 아래의 포스팅을 참조해 주시기 바랍니다.


Fedora에 이전 버전의 OpenJDK 설치하기(Install OpenJDK 7 in Fedora 23)

http://elecs.tistory.com/166


만약 설치한 이후에도 해당 버전이 적용되어 있지 않았을 경우 아래의 명령어를 통해 직접 설치해줍시다.


# alternatives --install /usr/bin/java java /usr/lib/jvm/java-1.7.0-openjdk/bin/java 1

# alternatives --install /usr/bin/javac javac /usr/lib/jvm/java-1.7.0-openjdk/bin/javac 1

# alternatives --install /usr/bin/javadoc javadoc /usr/lib/jvm/java-1.7.0-openjdk/bin/javadoc 1


3. dnf를 통해 안드로이드를 빌드하기 위해 필요한 패키지를 설치합니다. 


# dnf install bison gcc xorg-x11-fonts-Type1 libpng15 


4. 이제 다운로드 받은 소스코드를 build 하기 위한 준비과정을 진행해 보도록 하겠습니다. 먼저 build 환경을 초기화합니다.


$ ~/aosp

$ source build/envsetup.sh

$ lunch


 안드로이드 6.0.1 버전 기준으로 build 환경은 다음과 같이 나타납니다.


 여기서 자신이 build 하고자 하는 환경을 선택합니다. 본 포스팅의 경우 Android Studio를 통한 에뮬레이터에서의 실행을 목표로 함으로 1번 혹은 14번을 선택합니다. 혹시 자신이 build 하고자 하는 환경에 대한 설정을 알고 싶으신 분은 아래의 포스팅을 참조해 주시기 바랍니다.


안드로이드 프레임워크 프로그래밍(3) [NEXUS5에 소스 빌드하기]

http://elecs.tistory.com/59


5. 이제 build를 해보도록 합니다.


$ make update-api && make -j4


아래와 같은 결과가 나왔다면 Fedora 운영체제 환경에서 안드로이드 이미지를 빌드하는 데에 성공한 겁니다!


 


Fedora에서 Android Studio가 동작되지 않을 때[Unable to run mksdcard SDK tool]

 Fedora 23 버전에서 Android Studio를 설치해야 될 일이 있어 한 번 해보려는데 생소한 오류가 발생하였습니다.


Unable to run mksdcard SDK tool.



 이 경우 아래와 같은 명령어를 수행하여 설치해줍니다.


 #dnf install compat-libstdc++-296.i686 compat-libstdc++-33.i686 compat-libstdc++-33.x86_64 ncurses-libs.i686


 설치후 안드로이드 스튜디오를 다시 실행하시면 정상적으로 동작되는 것을 확인하실 수 있습니다.


$ ~/android-studio/bin/studio.sh



Windows 환경에서 fastboot를 통해 Android 이미지 포팅(Fastboot in Windows 7)

 Linux 환경에서 안드로이드 운영체제를 컴파일 하다 보니 안드로이드 이미지 포팅을 Linux로만 하게 되다보니 Windows 환경에서는 어떻게 하면 되는지 궁금했었는데 마침 기회가 되어 포스팅을 하게 되었습니다. 이번 포스팅에서는 Windows 환경에서 안드로이드 커널 이미지를 fastboot를 통해 설치해 보도록 합니다.


안드로이드 기기 : LG NEXUS 5

빌드 버전 : KitKat 4.4.4(r2)

운영체제 : Windows 7 SP1


 포스팅을 시작하기에 앞서 안드로이드 운영체제를 컴파일하여 이미지를 얻어내는 과정은 이전에 설명드렸던 포스팅을 참조해 주시길 바랍니다.


안드로이드 프레임워크 프로그래밍(3) [NEXUS5에 소스 빌드하기]

http://elecs.tistory.com/59


  1. 컴파일을 통해 완셩된 안드로이드 운영체제 이미지를 얻어냅니다. 이는 아래의 경로에서 얻으실 수 있습니다.


~/kitkat/out/target/product/hammerhead/


위에서 확인하실 수 있는 이미지(img) 파일 5개와 android-info.txt를 가져옵니다.


2. Windows 환경에서 Android SDK가 설치되어 있어야 합니다. Android SDK Manager를 실행하여 최하단 메뉴에 있는 Google USB Driver를 설치합니다.



3. 환경번수를 설정해줍니다. 컴퓨터에서 마우스 우측 클릭후 '속성'을 클릭합니다.



4. '고급 시스템 설정'을 클릭합니다.



5. 시스템 속성에서 '고급' 탭을 선택한 후 '환경 변수'를 클릭합니다.



6. 환경변수 창에서 시스템변수(S) 내에 Path를 더블클릭합니다.




7. 변수 값의 뒷부분에 다음 값을 추가합니다.


C:\Program Files\Android\android-sdk\platform-tools;


※주의!!

 절대로 변수 값의 내용을 지우시면 안됩니다! 만약 실수로 변수 값을 덮어쓰셨다면 바로 취소 버튼을 누릅니다. 만약 기존의 환경변수를 덮어쓰기로 모두 삭제할 경우 연결된 프로그램들이 동작을 하지 못하게 되는 참사가 발생합니다!

 만약 실수로 덮어쓰기 후 확인 버튼을 눌러 변수가 지워지신 분들은 절대로 당황하지 마시고 제가 이전에 포스팅한 내용을 따라가며 원래 환경 변수값을 복구하시길 바랍니다.


[윈도7] 환경변수 path 삭제시 복구하는 방법 ← 클릭하시면 새창으로 이동합니다.


========================================================================================================


8. 이번에는 안드로이드 운영체제 이미지가 위치하는 경로를 설정합니다. 아래 화면에서 '새로 만들기(W)'를 클릭합니다.

 

 

9. 새 시스템 변수의 변수 이름은 'ANDROID_PRODUCT_OUT'로, 변수 값은 안드로이드 커널 이미지가 위치한 파일 경로를 입력합니다. 본 포스팅에서는 E:\ 디스크에 안드로이드 커널 이미지를 두었습니다.



10. 이로서 Windows 환경에서 안드로이드 기기에 운영체제 이미지를 포팅할 준비를 마쳤습니다. 자신의 기기를 Fastboot 모드로 설정한 후 USB로 연결합니다.



11. Windows 운영체제가 안드로이드의 Fastboot 상태를 인식하게 되면 '드라이버 소프트웨어 설치'를 진행합니다. 아래와 같이 'Andorid Bootloader Interface'가 사용 준비 완료가 되기를 기다립니다.



12. CMD 창을 열어 다음과 같이 입력합니다.


> fastboot flashall



 위와 같은 화면이 나온다면 여러분들은 Windows 환경에서 fastboot를 통한 이미지 설치를 완료한 것입니다!


  • 세봉아 2015.11.27 10:42 ADDR 수정/삭제 답글

    벽돌된 것을 넥서스 5에 순정롬(6.0) 올리면 잘 동작됩니다

    질문 있습니다
    현재 제가 사용 하는 넥서스 5에 올려져 있는 버전이 안드로이드 6.0(마시멜로) 입니다
    리눅스에서 빌드 한 소스는 안드로이드 5.1.1.r3(Lollipop) 입니다
    넥서스 5에 맞게 빌드하기 위해 필요한 바이너리 파일과 팩토리 이미지는 모두 넥서스 5 기기와 동일한 6.0(마시멜로)으로 받아주었습니다.
    이렇게 하여 위 게시물 대로 진행 하였는데 현재 결과는 구글 무한반복 현상(벽돌만4회) 입니다
    버전을 일관성 있게 모두 맞춰야하나요?
    버전은 상관 없다는 분이 계셔서

    구글링했지만 비슷한 상황은 안보이네요.
    조언 좀 얻을 수 있을까요?

    • Justin T. 2015.11.27 11:00 신고 수정/삭제

      가장 기본적인 것은 자신에게 해당되는 기기와 버전을 모두 일치시키는 것이 기본입니다.
      즉, 롤리팝으로 올리시려면 바이너리 파일과 팩토리 파일 모두 롤리팝으로 맞추어주셔야 합니다. 물론 버전도 일치해야 하고요.

      그리고 자신의 기기보다 낮은 버전의 안드로이드를 설치하게 될 경우 로딩만 무한반복되는 현상이 종종 발견됩니다. 이 경우 공장초기화를 해주시면 정상적으로 동작하는 경우가 있습니다. 이는 아래 포스팅을 참조해주시기 바랍니다.
      http://elecs.tistory.com/63

  • 세봉아 2015.11.27 15:22 ADDR 수정/삭제 답글

    지금 버전을 맞추어서 이미지 포팅을 다시 해보려고 합니다.

    http://elecs.tistory.com/63
    상기 링크 확인하였습니다.
    그리고 구글 무한반복 현상은 저도 공장초기화를 여러 번 해주었는데 저는 해결되지 않았습니다.
    다른 경우 일수도 있겠다는 생각이 듭니다

Android Studio로 improt 한 후 컴파일 타겟 변경하기(failed to find target with hash string ...)

 최근 안드로이드 스튜디오로 건너온 이래로 차근차근 Eclipse에서 사용하던 project 들을 옮기고 있습니다. 그러던 중 몇몇 프로젝트의 경우 아래와 같은 에러가 발생하더군요.


Error : Cause : failed to find target with hash string 'android-15'


 이는 기존에 Eclipse 에서 사용하던 프로젝트가 Android Studio로 건너왔을 때 해당 버전에서 설정한 컴파일 sdk 버전이 없을 경우 위와 같은 에러가 발생합니다.



 해결 방법으로는 2가지의 경우가 있습니다.

1. 해당 Target에 해당하는 안드로이드 버전을 SDK Manager를 실행하여 다운로드 받는다.

2. 컴파일 버전을 자신의 SDK Manager가 가지고 있는 버전으로 변경합니다. 변경 방법은 아래와 같습니다.


자신의 프로젝트 폴더 -> app -> build.gradle


 해당 Gradle에서 compileSdkVersion을 변경해주면 프로젝트가 정상적으로 동작됨을 확인하실 수 있습니다.



안드로이드 - Java 서버간 Object 객체 소켓 프로그래밍

 Java를 기반으로 한 프로그래밍을 하다 보면 자신이 만든 Class 단위의 값을 전송하고 싶은 경우가 있습니다. 만약 서버가 C/C++ 기반으로 만들어진 경우 호환을 위해 Class 내의 값을 기본형인 int나 String으로 변환한 후 이를 Byte 값으로 변환하여 전송을 한 후 이 값을 받은 서버가 다시 C/C++에서 가공하기 편한 구조로 다시 변경하는 방식을 사용해야 되어서 프로그래밍을 할 때 다소 불편한 점이 있습니다.


 만약 서버가 Java를 기반으로 한다면 프로그래밍의 방식이 약간은 쉽게 바꿀 수 있습니다. 안드로이드와 서버 모두 Java를 사용하므로 Class를 통째로 넘겨주어도 이를 그대로 사용할 수 있다는 것입니다. 이 기능을 구현해주는 것이 바로 이번 포스팅에서 다루게 될 ObjectInputStreamObjectOutputStream 입니다. 바로 예제를 통해 이를 수행해보도록 합니다.


 먼저 Java 언어로 서버를 설계해보도록 합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
 
public class Server {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            int port = 8200;
            //서버에 사용할 포트 번호를 설정해줍니다.
            ServerSocket sock = new ServerSocket(port);
            //안드로이드 Client로부터 접속을 받을 준비를 합니다.
            Socket socket = sock.accept();
            //Socket로부터 받게 되는 InputStream을 설정합니다.
            InputStream is = socket.getInputStream();
            //InputStream의 최종 형식을 Object로 설정해줍니다.
            ObjectInputStream ois = new ObjectInputStream(is);
            
            //Socket로부터 받은 데이터를 Object로 수신합니다.
            String getString = (String)ois.readObject();
            System.out.println("receive : " + getString);
            
            ois.close();
            is.close();
            socket.close();
            sock.close();
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
    }
 
}
cs


다음으로 안드로이드에서 Java 서버로 Object를 전송할 수 있는 프로그램을 만들어봅니다.


activity_main.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activitymain"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:gravity="center_horizontal"     >
    
    <LinearLayout 
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        >
        
        <TextView
            android:layout_width="90dp"
            android:layout_height="wrap_content"
            android:text="IP주소" 
            />
        
        <EditText 
            android:id="@+id/ipaddr"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="192.168.1.1"
            />
        
    </LinearLayout>
    
    <LinearLayout 
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        >
        
        <TextView
            android:layout_width="90dp"
            android:layout_height="wrap_content"
            android:text="PORT 번호" 
            />
        
        <EditText 
            android:id="@+id/portnumber"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="8200"
            />
        
    </LinearLayout>
    
    <LinearLayout 
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        >
        
        <TextView
            android:layout_width="90dp"
            android:layout_height="wrap_content"
            android:text="보낼 내용" 
            />
        
        <EditText 
            android:id="@+id/sendserv"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="시스템프로그램설계"
            />
        
    </LinearLayout>
    
    <Button
        android:id="@+id/tryconnect"    
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="connect!"
        android:onClick="OnClick"
        />
    
</LinearLayout>
cs


MainActivity.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
 
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;
 
public class MainActivity extends Activity{
 
    private Handler mHandler = new Handler();
    private EditText ipaddr, portno, message;
    
    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        ipaddr = (EditText)findViewById(R.id.ipaddr);
        portno = (EditText)findViewById(R.id.portnumber);
        message = (EditText)findViewById(R.id.sendserv);
    }
    
    public void OnClick(View v) throws Exception{
        switch(v.getId()){
        case R.id.tryconnect:
            (new Connect()).start();
            break;
        }
    }
    
    class Connect extends Thread {
        public void run() {
            String ip = ipaddr.getText().toString();
            int port = Integer.parseInt(portno.getText().toString());
            String output = message.getText().toString();
            
            try {
                //서버에 접속합니다.
                Socket socket = new Socket(ip, port);
                //소켓으로부터 OutputStream을 설정합니다.
                OutputStream os = socket.getOutputStream();
                //OutputStream을 Object 방식으로 전송하도록 설정합니다.
                ObjectOutputStream oos = new ObjectOutputStream(os);
                
                //Object를 Socket을 통해 값을 전송합니다.
                oos.writeObject(output);
                
                oos.close();
                os.close();
                socket.close();
 
            } catch (Exception e) {
                // TODO Auto-generated catch block
                final String recvInput = "연결에 실패하였습니다.";
                mHandler.post(new Runnable() {
 
                    @Override
                    public void run() {
                        // TODO Auto-generated method stub
                        setToast(recvInput);
                    }
 
                });
 
            }
        }
    }
    
    void setToast(String msg) {
        Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
    }
 
}
 
 
cs


결과는 아래와 같습니다.


Client(안드로이드)측

Server측





  • QuickPerson 2016.03.04 10:32 신고 ADDR 수정/삭제 답글

    안드로이드 <-> 서버 간 Map 으로 넘기고 싶은데 방법좀 알려주실 수 있으시나요 ?!

    • Justin T. 2016.03.04 11:22 신고 수정/삭제

      질문이 구체적이지 않아서 무슨 말씀을 하고 싶은지 잘 모르겠습니다.
      그리고 가급적이면 포스팅의 내용과 관련된 질문 부탁드리겠습니다.

안드로이드 프레임워크 프로그래밍(26) [System Service에서 Activity 함수 호출하기]

 안드로이드 AIDL을 사용하여 RPC통신을 통해 Application 단계에서 Framework 단계의 method를 호출하는 방법에 대해 알아본 바 있습니다. 이번 포스팅에서는 Framework 단계에서 Application의 Activity에 존재하는 method를 호출하는 방법에 대해 알아보도록 하겠습니다.


 포스팅을 시작하기에 앞서 이전에 사용하였던 Application 단계에서 Framework 단계의 기능을 사용한 바 있습니다. 이에 대한 자세한 내용은 아래 포스팅을 참조해주시길 바랍니다. 또한 본 포스팅의 예제 또한 아래 포스팅의 것을 사용하였음을 알립니다.


안드로이드 프레임워크 프로그래밍(4) [시스템서비스 추가하기]

http://elecs.tistory.com/64


 안드로이드 Application을 실행하였을 때 Framework 단계에서 실행하고자 하는 method를 onCreate() 단계에서 등록을 합니다. 그 이후 System Service에서 특정 부분을 호출 받았을 때 Application의 Activity 내에 있는 함수를 실행하는 과정을 구현할 것입니다.


1. AIDL을 통해 Callback 함수 등록 및 해제 함수를 만들어줍니다.


/frameworks/base/core/java/android/os/ITestService.aidl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
* aidl file : frameworks/base/core/java/android/os/ITestService.aidl
* This file contains definitions of functions which are exposed by service
*/
package android.os;
 
import android.os.IActivityServiceCallback;
 
interface ITestService {
/**
* {@hide}
*/
    void setValue(int val);
    void execCallback(int val);
 
    /**
     * Often you want to allow a service to call back to its clients.
     * This shows how to do so, by registering a callback interface with
     * the service.
     */
    boolean registerCallback(IActivityServiceCallback cb);
    
    /**
     * Remove a previously registered callback interface.
     */
    boolean unregisterCallback(IActivityServiceCallback cb);
 
}
cs

 Activity에서 실행하고자 하는 method는 registerCallback() method를 통해 System Service에 등록할 수 있습니다. execCallback()함수는 이후 Application에서 RPC를 통해 호출을 받은 후 Callback 기능을 구현하기 위해 만든 함수입니다.


2. Activity로부터 호출하고자 하는 함수를 구현할 IActivityServiceCallback.aidl을 생성합니다.


/frameworks/base/core/java/android/os/IActivityServiceCallback.aidl

1
2
3
4
5
6
7
8
9
10
11
12
13
package android.os;
 
/**
 * Example of a callback interface used by IActivityService to send
 * synchronous notifications back to its clients.  Note that this is a
 * one-way interface so the server does not block waiting for the client.
 */
oneway interface IActivityServiceCallback {
    /**
     * Called when the service has a new value for you.
     */
    void callActivityMethod(int value);
}
cs

 위의 과정에서 만들어진 callActivityMethod() method는 이후 Activity에서 Callback 방식으로 구현될 것입니다. 다음으로 System Serivce에서 위의 새로 생성한 함수들을 구현해 보도록 하겠습니다.


/frameworks/base/services/java/com/android/server/TestService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
/*TestService.java */
package com.android.server;
import android.content.Context;
import android.os.Handler;
import android.os.IActivityServiceCallback;
import android.os.ITestService;
import android.os.Looper;
import android.os.Message;
import android.os.Process;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.util.Log;
 
public class TestService extends ITestService.Stub {
    private static final String TAG = "TestService";
    private TestWorkerThread mWorker;
    private TestWorkerHandler mHandler;
    private Context mContext;
 
    RemoteCallbackList<IActivityServiceCallback> callbacks =
                 new RemoteCallbackList<IActivityServiceCallback>();
 
    public TestService(Context context) {
        super();
        mContext = context;
        mWorker = new TestWorkerThread("TestServiceWorker");
        mWorker.start();
        Log.i(TAG, "Spawned worker thread");
    }
 
    public boolean registerCallback(IActivityServiceCallback cb) throws RemoteException{
        boolean flag = false;
        if(cb != null){
            flag = callbacks.register(cb);
        }
        return flag;
    }
 
    public boolean unregisterCallback(IActivityServiceCallback cb) throws RemoteException{
        boolean flag = false;
        if(cb != null){
            flag = callbacks.unregister(cb);
        }
        return flag;
    }
 
 
    public void setValue(int val) {
        Log.i(TAG, "setValue " + val);
        Message msg = Message.obtain();
        msg.what = TestWorkerHandler.MESSAGE_SET;
        msg.arg1 = val;
        mHandler.sendMessage(msg);
    }
 
    public void execCallback(int val){
     Message msg = Message.obtain();
        msg.what = TestWorkerHandler.CALLBACK;
        msg.arg1 = val;
        mHandler.sendMessage(msg);
    }
 
    private class TestWorkerThread extends Thread {
        public TestWorkerThread(String name) {
            super(name);
        }
        public void run() {
            Looper.prepare();
            mHandler = new TestWorkerHandler();
            Looper.loop();
        }
    }
 
    private class TestWorkerHandler extends Handler {
        private static final int MESSAGE_SET = 0;
        private static final int CALLBACK = 1;
 
        @Override
        public void handleMessage(Message msg) {
            try {
                if (msg.what == MESSAGE_SET) {
                    Log.i(TAG, "set message received: " + msg.arg1);
                }
                if (msg.what == CALLBACK) {
                    int n = callbacks.beginBroadcast();
                    for(int i = 0; i < n ; i++){
                        try {
                            Log.i(TAG, "callbacks.beginBroadcast()");
                            callbacks.getBroadcastItem(i).callActivityMethod(msg.arg1);
                        } catch (RemoteException e) {
                            e.printStackTrace();
                        }
                    }
                    callbacks.finishBroadcast();
                }
            } catch (Exception e) {
                // Log, don't crash!
                Log.e(TAG, "Exception in TestWorkerHandler.handleMessage:", e);
            }
        }
    }
}
cs

 RemoteCallbackList 클래스를 통해 Activity로부터 callback을 등록한 후 execCallback() method가 Application으로부터 호출되면 곧 System Service에서 등록한 callback을 실행하게 됩니다. 아래는 이를 구현한 Application 소스코드입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package com.example.test;
 
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.os.IActivityServiceCallback;
import android.os.ITestService;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.TextView;
import android.util.Log;
 
 
public class MainActivity extends Activity {
    private static final String DTAG = "HelloServer";
    ITestService om;
 
    IActivityServiceCallback mCallback = new IActivityServiceCallback.Stub() {
        
        @Override
        public void callActivityMethod(int arg0) throws RemoteException {
            // TODO Auto-generated method stub
            final int value = arg0;
            mHandler.post(new Runnable() {
 
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    setToast("callActivityMethod : " + value);
                }
            });
        }
    };
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        om = ITestService.Stub.asInterface(ServiceManager.getService("Test"));
        try{
            Log.d(DTAG, "Going to call service");
            om.setValue(20);
            om.registerCallback(mCallback);
            Log.d(DTAG, "Service called successfully");
        }catch(Exception e){
            Log.d(DTAG, "FAILED to call service");
            e.printStackTrace();
        }
        
    }
    
    public void OnClick(View v) throws RemoteException{
        switch(v.getId()){
            case R.id.button1:
                om.execCallback(100);
                break;
        }
    }
 
    void setToast(String msg) {
        Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
    }
 
    protected void onDestroy(){
        super.onDestroy();
        try {
            om.unregisterCallback(mCallback);
        } catch (RemoteException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
 
}
cs

 위 함수를 실행하면 다음과 같은 결과를 얻으실 수 있습니다.






Linux(우분투)에서 Android Studio 빠르게 실행하는 방법(바로가기 추가하기)

 안드로이드가 주로 애플리케이션 제작 도구로서 사용해오던 Eclipse에 대한 지원을 종료하게 됨에 따라 앞으로 안드로이드 Application을 개발하기 위해서는 안드로이드에서 자체적으로 제공하고 있는 IDE인 안드로이드 스튜디오(Android Studio)를 사용하는 것이 불가피하게 되었습니다.



안드로이드 애플리케이션 제작에 최적화 된 IDE인 Android Studio.

Eclipse에 익숙한 사용자들도 다양한 편의 기능에 개발 환경이 개선되었음을 체감할 수 있다.


 Windows 버전의 경우 필수 설치 프로그램만 설정되어 있다면 바로 설치 후 이용하실 수 있습니다만 Linux의 경우 studio.sh 파일 방식으로 실행을 해야 하기 때문에 Terminal을 사용해야 한다는 불편한 점이 있습니다.



기존 Eclipse에 익숙한 Linux 사용자에게도 Terminal을 통한 실행 방식은 번거롭고 불편하다.

 그렇다면 Linux 환경에서 Android Studio를 좀 더 쉽게 이용할 수 있는 방법은 없는 것일까요? 아래는 Terminal을 사용하지 않고 바로 Android Studio를 실행할 수 있는 방법들에 대해 다룬 내용입니다.


1) Dash Home을 통해 Android Studio 실행하기

 이 방법은 Android Studio에서 직접적으로 제공하는 방식으로서 별도의 설정 없이 바로 적용이 가능합니다.

- Android Studio를 실행한 후 Tools -> Create Desktop Entry... 를 실행합니다.



 실행을 하게 되면 아래와 같은 안내문이 나타납니다. 만약 다른 사용자가 사용할 수 있게 하고 싶다면 박스를 체크하신 후 OK 버튼을 클릭합니다.



 위의 과정을 완료한 후 Dash Home에 'android'를 검색하면 아래와 같이 Android Studio를 바로 실행할 수 있는 아이콘이 나타나는 것을 확인하실 수 있습니다.



2) 바탕화면(Desktop)에 바로가기 추가하기


 이 방법을 사용하면 바탕화면에 있는 아이콘을 더블클릭하여 바로 Android Studio를 실행할 수 있게 합니다.


$ vi android_studio.desktop


 android_studio.desktop 파일을 vi로 아래와 같은 내용을 작성합니다.

1
2
3
4
5
6
7
8
9
10
11
[Desktop Entry]
Version=1.0
Type=Application
Name=Android Studio
Exec="/home/자신의 폴더 경로/android-studio/bin/studio.sh" %f
Icon=/home/자신의 폴더 경로/android-studio/bin/studio.ico
Categories=Developement;IDE;
Terminal=false
StartupNotify=true
StartupWMClass=jetbrains-android-studio
Name[en_G0]=android-studio.desktop
cs

위와 같이 작성한 후 다음과 같은 명령어를 입력해줍니다.


$ chmod +x android_studio.desktop

$ mv ~/Desktop/ 또는 $ mv ~/바탕화면/


 위와 같은 과정을 거치신 후 자신의 바탕화면을 확인하면 Android Studio 바로가기 아이콘이 생성되어 있음을 확인할 수 있습니다. 실행하면 Android Studio가 정상적으로 실행됨을 확인하실 수 있습니다.




같은 공유기에 접속중인 안드로이드 기기 탐색 및 통신하기

 안드로이드 디바이스와 같이 휴대용 기기의 경우 Wi-Fi를 사용할 때 장소 및 환경에 따라 항상 같은 공유기를 사용할 수 만은 없지요. 또한 무선공유기(라우터)에 접속할 때 마다 할당 받는 IP 주소 또한 달라질 수 있기 때문에 Socket 통신을 하게 될 때 IP 주소를 고정 시킬 수 없어 변경된 IP 주소를 일일이 변경하여야만 합니다.


 그렇다면 번거롭게 IP 주소를 확인해야만 하는 걸까요? JAVA를 기반으로 하는 서버를 통한 통신 프로그래밍을 설계한다면 UDP 방식을 활용한 Broadcast 방식으로 공유기에 접속한 안드로이드 기기의 IP 주소를 알아낸 후 해당 IP를 통해 TCP 소켓 통신을 하는 방법이 있습니다.


 이번 포스팅에서는 같은 공유기(라우터)에 접속중인 서버가 UDP를 통해 현재 접속 중인 안드로이드 기기들을 탐색한 후 이에 응답을 한 안드로이드 기기의 IP 주소를 통해 TCP 방식의 Socket 통신이 이루어지는 과정에 대해 알아보도록 하겠습니다.


 본 포스팅의 소스코드는 이전에 작성하였던 아래 포스팅의 소스코드를 사용하였음을 밝힙니다. 혹시 서버에서의 UDP 통신에 대해 좀 더 알고 싶으신 분은 아래의 포스팅을 참조해 주시면 도움이 될 것입니다.


[JAVA] 같은 공유기에 접속중인 기기의 IP 주소 확인하는방법

http://elecs.tistory.com/153


-Server측(PC)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
 
public class Main {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
        RecvMesage rm = new RecvMessage();
        rm.start();
 
        for (int i = 0; i < 100; i++) {
            try {
                new SearchDevice("255.255.255.255"8200).start();
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
 
        rm.closeServer();
 
    }
 
    static class SearchDevice extends Thread {
        InetAddress ia;
        int port;
 
        SearchDevice(String IPaddr, int Port) {
            try {
                ia = InetAddress.getByName(IPaddr);
                port = Port;
            } catch (UnknownHostException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
 
        public void run() {
            String msg = "Hello, ELECS!";
            try {
                DatagramSocket ds = new DatagramSocket();
                int length = msg.length();
                byte[] msgbyte = msg.getBytes();
                DatagramPacket dp = new DatagramPacket(msgbyte, length, ia, port);
                //UDP 방식으로 공유기에 접속중인 모든 기기에 Packet을 전송합니다.
                ds.send(dp);
                ds.close();
 
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
 
    static class RecvMessage extends Thread {
        boolean ready = true;
        Socket socket;
        InputStream is;
        ObjectInputStream ois;
        String clientIp;
        ServerSocket sockserver;
        Object lock = new Object();
 
        public void closeServer() {
            try {
                synchronized (lock) {
                    sockserver.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
 
        public void run() {
            try {
                sockserver = new ServerSocket(8000);
                while (ready) {
                    //안드로이드 디바이스로부터 TCP 소켓 통신을 시작합니다.
                    socket = sockserver.accept();
                    synchronized (lock) {
                        is = socket.getInputStream();
                        ois = new ObjectInputStream(is);
 
                        //안드로이드 기기로부터 IP주소를 받아옵니다.
                        clientIp = (String) ois.readObject();
 
                        System.out.println("Client IP : " + clientIp);
                        ois.close();
                        is.close();
                        socket.close();
                    }
                }
 
            } catch (SocketException e) {
                System.out.println("ServerSocket is closed!");
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
cs


-Client측(안드로이드 디바이스)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
public class MainActivity extends AppCompatActivity {
    TextView tv1;
    Handler mHandler = new Handler();
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        tv1 = (TextView)findViewById(R.id.textview1);
        (new RecvUDP()).start();
    }
 
    class RecvUDP extends Thread{
        String text;
        String serverIp;
        DatagramPacket dp;
 
        public void run(){
            int port = 8200;
            byte[] message = new byte[1000];
            dp = new DatagramPacket(message, message.length);
            try {
                
                DatagramSocket ds = new DatagramSocket(port);
                //서버로부터 전달되는 Packet을 수신합니다.
                ds.receive(dp);
                text = new String(message, 0, dp.getLength());
                ds.close();
                //수신된 Packet으로부터 서버의 IP를 저장합니다.
                serverIp = dp.getAddress().getHostAddress();
 
                mHandler.post(new Runnable(){
 
                    @Override
                    public void run() {
                        tv1.setText(text);
                    }
                });
 
                WifiManager wifiMgr = (WifiManager) getSystemService(WIFI_SERVICE);
                WifiInfo wifiInfo = wifiMgr.getConnectionInfo();
                int ip = wifiInfo.getIpAddress();
 
                String androidIp = Formatter.formatIpAddress(ip);
 
                //서버의 IP를 통하여 Socket 통신을 시작합니다.
                Socket sock = new Socket(serverIp, 8000);
                DataOutputStream os = new DataOutputStream(sock.getOutputStream());
                ObjectOutputStream oos = new ObjectOutputStream(os);
                oos.writeObject(androidIp);
                oos.close();
                os.close();
                sock.close();
 
            } catch (Exception e) {
                e.printStackTrace();
            }
 
        }
    }
}
cs


-결과



Error: The SDK Build Tools revision is too low for project

 Eclipse에서 사용하던 프로젝트를 Android Studio로 가져왔을 때 아래와 같은 상황의 에러가 발생하였습니다.


Error: The SDK Build Tools revision (19.0.0) is too low for project. Minimum required is 19.1.0


 위 에러는 프로젝트가 기존 Eclipse에서 사용하던 Build Tools가 Android Studio에 설치된 Build Tools보다 버전이 낮아 발생하는 에러 입니다. 위 에러를 해결하기 위해서는 아래와 같은 과정을 수행합니다.


1.에러가 발생한 프로젝트의 폴더 -> build.grade 를 실행합니다.

2.android 부분에서 BuildToolsVersion 부분을 최소 요구 버전으로 설정합니다. 본 예제의 경우 버전을 19.1.0으로 수정합니다.



 위와 같이 적용한 후 Android Studio를 종료한 후 다시 실행하면 제대로 적용되어 있는 것을 확인하실 수 있습니다.