Using the LG G3 Circle Case SDK to Create a Demo Application

What is the Circle Case?

LG offers a unique accessory for its G3 model—a special case with several advanced features. This case supports NFC technology, wireless charging via the Qi standard (available in the European market), and includes a circular cutout on the front cover. This circular window allows users to interact with about one-third of the display using a customized GUI, providing quick access to certain apps and functions.

LG G3 SDK

To help developers leverage the circle case's features, LG released a lightweight SDK. The core functionality revolves around detecting the opening and closing of the case using a hidden magnet within the case and a sensor behind the screen. The SDK provides a broadcast receiver to capture these events.

Here's a basic example of how you can use this in your app:       

public class QCircleActivity extends Activity {

 // [START]declared in LGIntent.java of LG Framework
 public static final int EXTRA_ACCESSORY_COVER_OPENED = 0;
 public static final int EXTRA_ACCESSORY_COVER_CLOSED = 1;
 public static final String EXTRA_ACCESSORY_COVER_STATE = "com.lge.intent.extra.ACCESSORY_COVER_STATE";
  public static final String ACTI;

       // . . .

        private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
  @Override
  public void onReceive(Context context, Intent intent) {  

   //Receives a LG QCirle intent for the cover event
   if (ACTION_ACCESSORY_COVER_EVENT.equals(action)) {

    //Gets the current state of the cover
    mQuickCoverState = intent.getIntExtra(EXTRA_ACCESSORY_COVER_STATE,
      EXTRA_ACCESSORY_COVER_OPENED);

    if (mQuickCoverState == EXTRA_ACCESSORY_COVER_CLOSED) { // closed
     //Set window flags
     setQuickCircleWindowParam();
    } 
    else if (mQuickCoverState == EXTRA_ACCESSORY_COVER_OPENED) { // opened
      //Call FullScreenActivity
      Intent callFullscreen = new Intent(mContext, FullScreenActivity.class);
      startActivity(callFullscreen);
      
      //Finish QCircleActivity
      QCircleActivity.this.finish();
    }
   }
  }
 };

       // . . .
}

Customizing the GUI

For the graphical interface, you can use all standard layout widgets. However, only the portion of the layout visible through the circular cutout will be displayed to the user. You can address this by setting precise margin values to ensure your content fits within the circle.

Here's an example layout:

       


<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_gravity="top|center_horizontal"
    android:background="#000000">

    <RelativeLayout
        android:id="@+id/cover_main_view"
        android:layout_width="@dimen/physical_width_of_quickcircle"
        android:layout_height="@dimen/physical_height_of_quickcircle"
        android:layout_gravity="center_horizontal"
        android:background="@drawable/background">

        <!-- ... -->
    >/RelativeLayout<

</RelativeLayout>


Results of Testing

To experiment with the circle case feature, I decided to develop a quick game. The game utilizes the phone's accelerometer for control and the vibration feature for feedback. To manage game scores, I used Sugar ORM.

The objective of the game is simple: navigate a spaceship through as many gates as possible. With each gate passed, the game speeds up, increasing the challenge. Players tilt the device to control the rocket’s movement, making for an engaging and interactive experience.

I also published the game on the Google Play Store, and you can check out some screenshots below.

You can find the source code here: 



Comments

Post a Comment

Popular posts from this blog

Skate Tricks Recognition Using Gyroscope

Image
In this article, we’ll describe how to recognize skateboard tricks using a gyroscope. This sensor is already present in most smartphones, but if you’re not familiar with it, here is a description . Before we dive in, a small disclaimer: This project originated as part of a Slido hackathon with the goal of demonstrating that it’s possible to recognize skateboard tricks using a gyroscope. For simplicity, we’ll focus on recognizing just two basic tricks and won’t consider the skater’s stance on the board. We’ll break down the problem into several smaller tasks: recording the trick, storing the data, describing the trick, analyzing it, and, finally, recognizing it. Recording the Trick Let’s start with trick recording. To obtain precise data, the device with the gyroscope needs to be attached directly to the skateboard. Place it on the bottom of the board to avoid interfering with the execution of the trick. The device should also be compact and lightweight to avoid altering the board’s cen...
Read more

Play table

Image
Using proximity sensors for playing midi tones combined with LED visualization Description The goal of this project was to create a table-sized device equipped with multiple proximity sensors capable of playing MIDI tones. Each sensor is accompanied by LEDs that indicate the distance of the user's hand above the table. This interactive table can be used by one or more people simultaneously. Hardware Setup I began with a cardboard prototype to test the sensors and the underlying logic. Afterward, I ordered a custom plottered sticker with a design which was painted with bare conductive paint. I drilled holes and connected the touchboard to seven Arduino Nanos, each controlling 13 LEDs. Additionally, I incorporated two potentiometers: one for volume control and another for changing the note setup. Programming The programming task was divided into two parts: Master Program (Touchboard): Reads values from the proximity sensors and sends messages to the slave Arduinos. Sl...
Read more

Counting dice and train wagons using computer vision

Image
Computer vision exercises with preprocessing Before starting my next project, I decided to work on some computer vision exercises. Each example is based on straightforward image preprocessing techniques. No complex data structures or machine learning are involved. Dice Detection I got this idea while browsing the net and became curious about how challenging it would be to write such a script. Here’s a step-by-step breakdown of the algorithm: Movement Detection : By comparing several frames with thresholds, we can determine if there is any movement in the frame. Adding a small time buffer after the movement stops gives us more accurate information. Removing the Background : Thresholding the grayscale frame helps to remove the background, leaving us with a binary image that highlights the objects. Cropping the Objects : Using contours, we can detect and isolate the objects by cropping them. Detecting Dots : By inverting the image, the dots on the dice become more distinguish...
Read more